http-request-manager 18.15.34 → 18.16.1

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

@@ -1,727 +0,0 @@
-import { Inject, inject, Injectable, Injector, Optional } from '@angular/core';
-import { HttpErrorResponse } from '@angular/common/http';
-import { BehaviorSubject, Observable, Subject, throwError, from, of } from 'rxjs';
-import { tap, map, finalize, catchError, concatMap, mergeMap, toArray, concat } 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, BatchOptions, BatchResult, BatchRequestState } from '../../models';
-import { ObjectMergerService } from '../utils/object-merger.service';
-import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
-import { WebSocketManagerService } from '../ws-manager-service/websocket-service';
-import { MessageTrackerService } from '../ws-manager-service/message-tracker.service';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class HTTPManagerService<T> extends RequestService {
-
-  toastMessage = inject(ToastMessageDisplayService)
-  ng_injector = inject(Injector)
-  objectMergerService = inject(ObjectMergerService)
-  wsManager = inject(WebSocketManagerService)
-  messageTracker = inject(MessageTrackerService)
-
-  // Delegate WebSocket observables to WebSocketManagerService (singleton)
-  override connectionStatus$ = this.wsManager.connectionStatus$
-  override messages$ = this.messageTracker.messages$ // Messages flow through MessageTrackerService
-  override subscribedChannels$ = this.wsManager.subscribedChannels$
-  retryCount$ = this.wsManager.retryCount$
-  maxRetries$ = this.wsManager.maxRetries$
-
-  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();
-
-  override streamProgress$ = this.streamProgress.asObservable();
-
-  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
-    super()
-    this.config = (configOptions) ? ApiRequest.adapt(configOptions.httpRequestOptions) : this.config
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // WEBSOCKET METHODS (Delegated to WebSocketManagerService singleton)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Connect to WebSocket server
-   * Only the first call across ALL instances will establish a connection
-   */
-  override connect(options: any, jwtToken: string): void {
-    this.wsManager.connect(options, jwtToken);
-  }
-
-  /**
-   * Disconnect from WebSocket server
-   */
-  override disconnect(): void {
-    this.wsManager.disconnect();
-  }
-
-  /**
-   * Subscribe to a channel
-   */
-  override subscribeToChannel(channel: string, userData?: any): void {
-    this.messageTracker.subscribeToChannel(channel, userData);
-  }
-
-  /**
-   * Subscribe to multiple channels
-   */
-  override subscribeToChannels(channels: string[], userData?: any): void {
-    channels.forEach(channel => this.messageTracker.subscribeToChannel(channel, userData));
-  }
-
-  /**
-   * Unsubscribe from a channel
-   */
-  override unsubscribeFromChannel(channel: string): void {
-    this.wsManager.unsubscribeFromChannel(channel);
-  }
-
-  /**
-   * Get currently subscribed channels
-   */
-  override getSubscribedChannels(): Set<string> {
-    return this.wsManager.getSubscribedChannels();
-  }
-
-  /**
-   * Send broadcast message
-   */
-  override sendBroadcast(content: any): void {
-    this.wsManager.sendBroadcast(content);
-  }
-
-  /**
-   * Send message in channel (state manager message)
-   */
-  override sendMessageInChannel(channel: string, content: any): void {
-    this.wsManager.sendMessageInChannel(channel, content);
-  }
-
-  /**
-   * Send channel message
-   */
-  override sendChannelMessage(channel: string, content: any): void {
-    this.wsManager.sendChannelMessage(channel, content);
-  }
-
-  /**
-   * Send message to multiple channels
-   */
-  override sendChannelMessageToChannels(channels: string[], content: any): void {
-    this.wsManager.sendChannelMessageToChannels(channels, content);
-  }
-
-  /**
-   * Send message to user
-   */
-  override sendMessageToUser(user: string, content: any): void {
-    this.wsManager.sendMessageToUser(user, content);
-  }
-
-  /**
-   * Get all channels
-   */
-  override getAllChannels(): void {
-    this.wsManager.getAllChannels();
-  }
-
-  /**
-   * Create channel
-   */
-  override createChannel(channel: string): void {
-    this.wsManager.createChannel(channel);
-  }
-
-  /**
-   * Delete channel
-   */
-  override deleteChannel(channel: string): void {
-    this.wsManager.deleteChannel(channel);
-  }
-
-  /**
-   * Get users in channel
-   */
-  override getUsersInChannel(channel: string): void {
-    this.wsManager.getUsersInChannel(channel);
-  }
-
-  /**
-   * Create notification channel
-   */
-  override createNotificationChannel(channel: string): void {
-    this.wsManager.createNotificationChannel(channel);
-  }
-
-  /**
-   * Get notification channels
-   */
-  override getNotificationChannels(): void {
-    this.wsManager.getNotificationChannels();
-  }
-
-  /**
-   * Get today's notification channels
-   */
-  override getTodaysNotificationChannels(): void {
-    this.wsManager.getTodaysNotificationChannels();
-  }
-
-  /**
-   * Subscribe to notification channel
-   */
-  override subscribeToNotificationChannel(channel: string, options?: any, user?: any): void {
-    this.wsManager.subscribeToNotificationChannel(channel, options, user);
-  }
-
-  /**
-   * Unsubscribe from notification channel
-   */
-  override unsubscribeFromNotificationChannel(channel: string): void {
-    this.wsManager.unsubscribeFromNotificationChannel(channel);
-  }
-
-  /**
-   * Send notification to channel
-   */
-  override sendNotification(channel: string, content: any): void {
-    this.wsManager.sendNotification(channel, content);
-  }
-
-  // REQUESTS
-
-  getRequest<T>(options?: ApiRequest, params?: any[]) {
-
-    this.isPending.next(true);
-    this.data.next(null)
-    this.streamProgress.next({
-      received: 0,
-      total: undefined,
-      percent: 0,
-      stage: 'connecting'
-    });
-
-    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)
-        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
-      }),
-      finalize(() => {
-        this.streamProgress.next({
-          ...this.streamProgress.value,
-          stage: 'complete'
-        });
-        this.isPending.next(false)
-      }),
-      catchError((err) => {
-        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
-        this.streamProgress.next({
-          ...this.streamProgress.value,
-          stage: 'error'
-        });
-        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)
-        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
-      }),
-      finalize(() => this.isPending.next(false)),
-      catchError((err) => {
-        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
-        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)
-        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
-      }),
-      finalize(() => this.isPending.next(false)),
-      catchError((err) => {
-        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
-        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)
-        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
-      }),
-      finalize(() => this.isPending.next(false)),
-      catchError((err) => {
-        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
-        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);
-      })
-    )
-
-  }
-
-  uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]) {
-
-    this.isPending.next(true);
-    this.data.next(null)
-
-    const updatedOptions = this.defineReqOptions(options, params)
-    updatedOptions.uploadFiles = files
-
-    const func = this.uploadFileRequest;
-    const requests = this.createRequest(func, updatedOptions);
-
-    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(
-      tap(data => {
-        this.data.next(data)
-        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
-      }),
-      finalize(() => this.isPending.next(false)),
-      catchError((err) => {
-        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
-        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(
-      (options?.retry && options.retry.times > 0)
-        ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)
-        : (source: Observable<T>) => source,
-      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);
-      })
-    );
-  }
-
-  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, message?: string) {
-
-    const displayError = ToastDisplay.adapt({
-            message: message || error.message || `${error.status} - ${error.statusText}`,
-            action: 'OK',
-            color: ToastColors.ERROR,
-            icon: 'error',
-            duration: 5 * 1000, //5 seconds
-          })
-
-    this.toastMessage.toastMessage(displayError)
-
-  }
-
-  private handleSuccessWithSnackBar(message?: string) {
-
-    const displaySuccess = ToastDisplay.adapt({
-            message: message || 'Success',
-            action: 'OK',
-            color: ToastColors.SUCCESS,
-            icon: 'check_circle',
-            duration: 3 * 1000, //3 seconds
-          })
-
-    this.toastMessage.toastMessage(displaySuccess)
-
-  }
-
-  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
-
-  }
-
-  // BATCH REQUESTS
-
-  /**
-   * Execute multiple HTTP requests with configurable execution strategy
-   * @param requests Array of ApiRequest configurations
-   * @param options Optional batch configuration (all properties optional)
-   * @returns Observable emitting array of data in the order of requests provided
-   */
-  getBatchRequests<U = T>(
-    requests: ApiRequest[],
-    options?: BatchOptions
-  ): Observable<U[]> {
-    const batchOptions = BatchOptions.adapt(options);
-
-    const mode = batchOptions.mode || 'sequential';
-
-    if (mode === 'parallel') {
-      return this.getParallelRequest(requests, batchOptions);
-    } else {
-      return this.getSequentialRequest(requests, batchOptions);
-    }
-  }
-
-  /**
-   * Execute requests sequentially (one at a time, in order)
-   * @param requests Array of ApiRequest configurations
-   * @param options Optional batch configuration
-   * @returns Observable emitting array of data when all requests complete
-   */
-  getSequentialRequest<U = T>(
-    requests: ApiRequest[],
-    options?: BatchOptions,
-    successMessage?: string,
-    errorMessage?: string
-  ): Observable<U[]> {
-    const batchOptions = BatchOptions.adapt(options);
-    const results: U[] = new Array(requests.length);
-
-    return from(requests).pipe(
-      concatMap((req, index) => {
-        return this.getRequest<U>(req, undefined).pipe(
-          tap(data => {
-            results[index] = data;
-          }),
-          catchError(error => this.handleSequentialError(req, error, index, batchOptions))
-        );
-      }),
-      toArray(),
-      tap(() => {
-        if (batchOptions.displaySuccess) this.handleSuccessWithSnackBar(successMessage);
-      }),
-      map(() => results)
-    );
-  }
-
-  /**
-   * Execute requests in parallel with concurrency control
-   * @param requests Array of ApiRequest configurations
-   * @param options Optional batch configuration with concurrency limit
-   * @returns Observable emitting array of data when all requests complete
-   */
-  getParallelRequest<U = T>(
-    requests: ApiRequest[],
-    options?: BatchOptions,
-    successMessage?: string,
-    errorMessage?: string
-  ): Observable<U[]> {
-    const batchOptions = BatchOptions.adapt(options);
-    const concurrency = batchOptions.concurrency || 3;
-    const results: U[] = new Array(requests.length);
-
-    return from(requests).pipe(
-      mergeMap((req, index) => {
-        return this.getRequest<U>(req, undefined).pipe(
-          tap(data => {
-            results[index] = data;
-          }),
-          catchError(error => this.handleParallelError(req, error, index, batchOptions))
-        );
-      }, concurrency),
-      toArray(),
-      tap(() => {
-        if (batchOptions.displaySuccess) this.handleSuccessWithSnackBar(successMessage);
-      }),
-      map(() => results)
-    );
-  }
-
-  /**
-   * Execute multiple HTTP requests and emit individual state changes in real-time
-   * @param requests Array of ApiRequest configurations
-   * @param options Optional batch configuration (all properties optional)
-   * @returns Observable stream of individual request states
-   */
-  getBatchRequestsStream<U = T>(
-    requests: ApiRequest[],
-    options?: BatchOptions
-  ): Observable<BatchRequestState<U>> {
-    const batchOptions = BatchOptions.adapt(options);
-    const mode = batchOptions.mode || 'sequential';
-
-    if (mode === 'parallel') {
-      return this.getParallelStream(requests, batchOptions);
-    } else {
-      return this.getSequentialStream(requests, batchOptions);
-    }
-  }
-
-  /**
-   * Execute requests sequentially and emit state changes
-   */
-  private getSequentialStream<U>(
-    requests: ApiRequest[],
-    options: BatchOptions
-  ): Observable<BatchRequestState<U>> {
-    return from(requests).pipe(
-      concatMap((req, index) => {
-        const pending$: Observable<BatchRequestState<U>> = of({
-          index,
-          request: req,
-          isPending: true
-        });
-
-        const result$: Observable<BatchRequestState<U>> = this.getRequest<U>(req).pipe(
-          map((data) => ({
-            index,
-            request: req,
-            isPending: false,
-            data
-          }) as BatchRequestState<U>),
-          catchError((error) => of({
-            index,
-            request: req,
-            isPending: false,
-            error
-          } as BatchRequestState<U>))
-        );
-
-        return pending$.pipe(
-          concatMap(() => result$)
-        );
-      })
-    );
-  }
-
-  /**
-   * Execute requests in parallel and emit state changes
-   */
-  private getParallelStream<U>(
-    requests: ApiRequest[],
-    options: BatchOptions
-  ): Observable<BatchRequestState<U>> {
-    const concurrency = options.concurrency || 3;
-
-    return from(requests).pipe(
-      mergeMap((req, index) => {
-        const pending$: Observable<BatchRequestState<U>> = of({
-          index,
-          request: req,
-          isPending: true
-        });
-
-        const result$: Observable<BatchRequestState<U>> = this.getRequest<U>(req).pipe(
-          map((data) => ({
-            index,
-            request: req,
-            isPending: false,
-            data
-          }) as BatchRequestState<U>),
-          catchError((error) => of({
-            index,
-            request: req,
-            isPending: false,
-            error
-          } as BatchRequestState<U>))
-        );
-
-        return pending$.pipe(
-          concatMap(() => result$)
-        );
-      }, concurrency)
-    );
-  }
-
-  private handleSequentialError<U>(
-    request: ApiRequest,
-    error: any,
-    index: number,
-    options: BatchOptions
-  ): Observable<U> {
-    if (options.logErrors !== false) {
-      console.error(`Batch request ${index} failed:`, error);
-    }
-
-    if (options.stopOnError) {
-      return throwError(() => error);
-    }
-
-    if (options.ignoreErrors) {
-      return of(undefined as unknown as U);
-    }
-
-    return throwError(() => error);
-  }
-
-  private handleParallelError<U>(
-    request: ApiRequest,
-    error: any,
-    index: number,
-    options: BatchOptions
-  ): Observable<U> {
-    if (options.logErrors !== false) {
-      console.error(`Batch request ${index} failed:`, error);
-    }
-
-    if (options.ignoreErrors) {
-      return of(undefined as unknown as U);
-    }
-
-    return of(undefined as unknown as U);
-  }
-}
-