http-request-manager 18.7.20 → 18.7.21

package/src/lib/services/request-manager-services/http-manager.service.spec.ts

@@ -0,0 +1,232 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
+import { HTTPManagerService } from './http-manager.service';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { HttpErrorResponse, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+
+import { ToastMessageDisplayService } from 'toast-message-display';
+
+
+interface TestData {
+  id?: string | number;
+  name: string;
+}
+
+describe('HTTPManagerService', () => {
+  let service: HTTPManagerService<TestData>;
+  let httpMock: HttpTestingController;
+  let toastMessageServiceSpy: jasmine.SpyObj<ToastMessageDisplayService>;
+  let objectMergerServiceSpy: jasmine.SpyObj<ObjectMergerService>;
+
+  const mockConfig = {
+    httpRequestOptions: {
+      server: 'http://test-api.com',
+      path: [],
+      headers: {}
+    }
+  };
+
+  beforeEach(() => {
+    toastMessageServiceSpy = jasmine.createSpyObj('ToastMessageService', ['toastMessage']);
+    objectMergerServiceSpy = jasmine.createSpyObj('ObjectMergerService', ['mergeOptions']);
+    objectMergerServiceSpy.mergeOptions.and.callFake((options?: ApiRequest) => {
+      return options || ApiRequest.adapt();
+    });
+
+    TestBed.configureTestingModule({
+    imports: [],
+    providers: [
+        HTTPManagerService,
+        { provide: ToastMessageDisplayService, useValue: toastMessageServiceSpy },
+        { provide: ObjectMergerService, useValue: objectMergerServiceSpy },
+        { provide: CONFIG_SETTINGS_TOKEN, useValue: mockConfig },
+        provideHttpClient(withInterceptorsFromDi()),
+        provideHttpClientTesting()
+    ]
+});
+
+    service = TestBed.inject(HTTPManagerService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('getRequest', () => {
+    it('should make a GET request and handle success', (done) => {
+      const testData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        displayError: true
+      });
+
+      service.getRequest<TestData>(options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      expect(req.request.method).toBe('GET');
+      req.flush(testData);
+    });
+  });
+
+  describe('postRequest', () => {
+    it('should make a POST request and handle success', (done) => {
+      const testData: TestData = { id: undefined, name: 'Test' };
+      const responseData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test']
+      });
+
+      service.postRequest<TestData>(testData, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(responseData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body).toEqual(testData);
+      req.flush(responseData);
+    });
+  });
+
+  describe('putRequest', () => {
+    it('should make a PUT request and handle success', (done) => {
+      const testData: TestData = { id: 1, name: 'Updated Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test', 1]
+      });
+
+      service.putRequest<TestData>(testData, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test/1');
+      expect(req.request.method).toBe('PUT');
+      expect(req.request.body).toEqual(testData);
+      req.flush(testData);
+    });
+  });
+
+  describe('deleteRequest', () => {
+    it('should make a DELETE request and handle success', (done) => {
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test', 1]
+      });
+
+      service.deleteRequest(options).subscribe({
+        next: (response) => {
+          expect(response).toBeNull();
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test/1');
+      expect(req.request.method).toBe('DELETE');
+      req.flush(null);
+    });
+  });
+
+  describe('Polling', () => {
+    let clock: jasmine.Clock;
+
+    beforeEach(() => {
+      clock = jasmine.clock();
+      clock.install();
+    });
+
+    afterEach(() => {
+      clock.uninstall();
+    });
+
+    it('should handle polling requests', (done) => {
+      const testData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        polling: 5
+      });
+
+      let callCount = 0;
+
+      // Force synchronous execution of observables
+      jasmine.clock().mockDate(new Date());
+
+      const subscription = service.getRequest<TestData>(options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          callCount++;
+
+          if (callCount === 1) {
+            // Trigger the next polling cycle
+            clock.tick(5000);
+          }
+
+          if (callCount === 2) {
+            subscription.unsubscribe();
+            service['stopPolling']();
+            done();
+          }
+        },
+        error: (error) => {
+          subscription.unsubscribe();
+          done.fail(error);
+        }
+      });
+
+      // Handle first request
+      const req1 = httpMock.expectOne('http://test-api.com/test');
+      expect(req1.request.method).toBe('GET');
+      req1.flush(testData);
+
+      // Wait for the next polling cycle
+      clock.tick(5000);
+
+      // Handle second request
+      const req2 = httpMock.expectOne('http://test-api.com/test');
+      expect(req2.request.method).toBe('GET');
+      req2.flush(testData);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle network errors', (done) => {
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        displayError: true
+      });
+
+      service.getRequest<TestData>(options).subscribe({
+        error: (error) => {
+          expect(error instanceof HttpErrorResponse).toBeTrue();
+          expect(service.isPending.getValue()).toBeFalse();
+          expect(toastMessageServiceSpy.toastMessage).toHaveBeenCalled();
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      req.error(new ErrorEvent('Network error'));
+    });
+  });
+});

package/src/lib/services/request-manager-services/http-manager.service.ts

@@ -0,0 +1,274 @@
+import { Inject, inject, Injectable, Injector, Optional } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { BehaviorSubject, Observable, Subject, throwError } from 'rxjs';
+import { tap, map, finalize, catchError } from 'rxjs/operators';
+
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { RequestService } from './request.service';
+import { requestPolling, countdown, delayedRetry } from './rxjs-operators';
+
+
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigOptions } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HTTPManagerService<T> extends RequestService {
+
+  toastMessage = inject(ToastMessageDisplayService)
+  ng_injector = inject(Injector)
+  objectMergerService = inject(ObjectMergerService)
+
+  private countdown = new BehaviorSubject<number>(0);
+  countdown$ = this.countdown.asObservable();
+
+  private error = new BehaviorSubject<boolean>(false);
+  error$ = this.error.asObservable();
+
+  private data = new BehaviorSubject<any>(null)
+  data$ = this.data.asObservable()
+
+  private polling$ = new Subject<void>();
+
+  config = ApiRequest.adapt();
+
+  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
+    super()
+    this.config = (configOptions) ? ApiRequest.adapt(configOptions.httpRequestOptions) : this.config
+  }
+
+  // REQUESTS
+
+  getRequest<T>(options?: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.getRecordRequest;
+    const requests = this.createRequest(func, updatedOptions);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name)
+    .pipe(
+      tap(data => this.data.next(data))
+    ).pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          this.isPending.next(false)
+          return this.handleError(err);
+        })
+      )
+  }
+
+  postRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.createRecordRequest;
+    const requests = this.createRequest(func, updatedOptions, data);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(tap(data => this.data.next(data)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          this.isPending.next(false)
+          return this.handleError(err);
+        })
+      )
+  }
+
+  putRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.updateRecordRequest;
+    const requests = this.createRequest(func, updatedOptions, data);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(tap(data => this.data.next(data)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+            this.isPending.next(false)
+          return this.handleError(err);
+        })
+      )
+  }
+
+  deleteRequest<T>(options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.deleteRecordRequest;
+    const requests = this.createRequest(func, updatedOptions);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(tap(data => this.data.next(data)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          this.isPending.next(false)
+          return this.handleError(err);
+        })
+      )
+  }
+
+  downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string) {
+
+    this.isPending.next(true);
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.downloadFileRequest;
+    const requests = this.createRequest(func, updatedOptions)
+
+    return this.createObservable<T>(updatedOptions, requests, func.name)
+    .pipe(
+      catchError((err) => {
+        this.error.next(true)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+
+  }
+
+  private createObservable<T>(options: ApiRequest, request$: Observable<T>, funcName: string) {
+
+    const polling = options.polling ? (options.polling > 0 ? true : false) : false;
+    const isPolling =
+      polling &&
+      !(funcName === 'deleteRecordRequest' || funcName === 'updateRecordRequest' || funcName === 'createRecordRequest')
+        ? true
+        : false;
+
+    this.polling$.next();
+
+    const polling$ =
+      (isPolling && options.polling) || 0 >= 3
+        ? request$.pipe(
+            requestPolling((options.polling || 0) + 1, this.polling$, this.isPending),
+            tap(() => this.countdown.next(0)),
+            tap(() => {
+              if (!options.polling) return;
+              const count = options.polling ? options.polling : 0;
+              // console.log('COUNT:', count);
+              countdown(count)
+                .pipe(
+                  map((x: number) => {
+                    // console.log('XX:', count, x);
+                    const pollingInSec = options.polling || 0;
+                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;
+                    return Math.round(percentageCompleted);
+                  })
+                )
+                .subscribe((countDownValue: number) => {
+                  // console.log(this.countdown.value, countDownValue);
+                  this.countdown.next(countDownValue);
+                });
+            }),
+          )
+        : request$.pipe(
+            catchError((err: any) => {
+
+              if (err instanceof HttpErrorResponse) {
+                this.error.next(true);
+                return this.handleError(err);
+              }
+
+              return throwError(() => err);
+            }),
+            // finalize(() => this.isPending.next(false))
+          )
+
+    return polling$.pipe(
+      catchError((err: any, caught: Observable<T>) => {
+
+        if (err instanceof HttpErrorResponse) {
+          this.error.next(true);
+          if(isPolling) this.stopPolling();
+          return this.handleError(err);
+        }
+
+        return throwError(() => err);
+      }),
+      (options?.retry && options.retry.times > 0)
+        ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)
+        : (source: Observable<T>) => source
+    );
+  }
+
+  private createRequest(func: Function, options: ApiRequest, data?: any | any[]) {
+    const dataItem = this.prepareRequestData(options, data, func.name);
+    return func.bind(this)(dataItem.options, dataItem.data);
+  }
+
+  private prepareRequestData(options: ApiRequest, data: any, funcName: string) {
+
+    if ((options.mapper && funcName === 'updateRecordRequest') || funcName === 'createRecordRequest') {
+      if (options?.mapper) {
+        data = options.mapper
+          ? Array.isArray(data)
+            ? map((item) => options.mapper(item))
+            : options.mapper(data)
+          : data;
+      }
+    } else {
+      if (options?.adapter) {
+        data = Array.isArray(data)
+            ? map((item) => options.adapter(item))
+            : options.adapter(data)
+      }
+    }
+
+    return { options: options, data: data };
+  }
+
+  // MISC
+
+  private handleError(error: Response | any) {
+    this.error.next(error.message || `${error.status} - ${error.statusText}`)
+    return throwError(() => error)
+  }
+
+  private handleErrorWithSnackBar(error: Response | any) {
+
+    const displayError = ToastDisplay.adapt({
+            message: error.message || `${error.status} - ${error.statusText}`,
+            action: 'OK',
+            color: ToastColors.ERROR,
+            icon: 'error',
+            duration: 5 * 1000, //5 seconds
+          })
+
+    this.toastMessage.toastMessage(displayError)
+
+  }
+
+  private stopPolling() {
+    this.isPending.next(false);
+    this.polling$.next();
+  }
+
+  private defineReqOptions(options: any, params?: any[]) {
+
+    const req = ApiRequest.adapt(options)
+    if(req?.path) req.path = (params) ? [...req.path, ...params] : req.path
+
+    const optionsReq = (req)? req : ApiRequest.adapt()
+    const updatedOptions = this.objectMergerService.mergeOptions(optionsReq)
+
+    return updatedOptions
+
+  }
+}

package/src/lib/services/request-manager-services/index.ts

@@ -0,0 +1,8 @@
+export * from "./http-manager.service";
+export * from "./http-manager-signals.service";
+
+export * from './request.service';
+export * from './request-signals.service';
+
+export * from "../../models/index";
+export * from "./rxjs-operators/index";