http-request-manager 18.15.34 → 18.16.1

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

@@ -1,674 +0,0 @@
-import { Inject, inject, Injectable, Injector, Optional, signal } from '@angular/core';
-import { HttpErrorResponse } from '@angular/common/http';
-import { 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 { RequestSignalsService } from './request-signals.service';
-import { requestPolling, countdown, delayedRetry } from './rxjs-operators';
-
-import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
-import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
-import { ConfigOptions, BatchOptions, BatchResult, BatchRequestState } from '../../models';
-import { ObjectMergerService } from '../utils/object-merger.service';
-import { WebSocketManagerService } from '../ws-manager-service/websocket-service';
-import { MessageTrackerService } from '../ws-manager-service/message-tracker.service';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class HTTPManagerSignalsService<T> extends RequestSignalsService {
-
-  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$;
-  override subscribedChannels$ = this.wsManager.subscribedChannels$;
-
-  // ✅ Replaced BehaviorSubjects with Angular signals
-  countdown = signal<number>(0);
-  error = signal<string | boolean>(false);
-  data = signal<any>(null);
-
-  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;
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // WEBSOCKET METHODS (Delegated to WebSocketManagerService singleton)
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Connect to WebSocket server
-   */
-  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.set(true);
-    this.data.set(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.set(data);
-        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
-      }),
-      finalize(() => this.isPending.set(false)),
-      catchError((err) => {
-        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-
-  postRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
-    this.isPending.set(true);
-    this.data.set(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.set(data);
-        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
-      }),
-      finalize(() => this.isPending.set(false)),
-      catchError((err) => {
-        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-
-  putRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
-    this.isPending.set(true);
-    this.data.set(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.set(data);
-        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
-      }),
-      finalize(() => this.isPending.set(false)),
-      catchError((err) => {
-        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-
-  deleteRequest<T>(options: ApiRequest, params?: any[]) {
-    this.isPending.set(true);
-    this.data.set(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.set(data);
-        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
-      }),
-      finalize(() => this.isPending.set(false)),
-      catchError((err) => {
-        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-
-  downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string) {
-    this.isPending.set(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.set(true);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-  uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]) {
-    this.isPending.set(true);
-    this.data.set(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.set(data);
-        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
-      }),
-      finalize(() => this.isPending.set(false)),
-      catchError((err) => {
-        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message);
-        this.isPending.set(false);
-        return this.handleError(err);
-      })
-    );
-  }
-
-  // --- private helpers ---
-  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');
-
-    this.polling$.next();
-
-    const polling$ =
-      (isPolling && options.polling) || 0 >= 3
-        ? request$.pipe(
-            requestPolling((options.polling || 0) + 1, this.polling$, this.isPending),
-            tap(() => this.countdown.set(0)),
-            tap(() => {
-              if (!options.polling) return;
-              const count = options.polling ? options.polling : 0;
-              countdown(count)
-                .pipe(
-                  map((x: number) => {
-                    const pollingInSec = options.polling || 0;
-                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;
-                    return Math.round(percentageCompleted);
-                  })
-                )
-                .subscribe((countDownValue: number) => {
-                  this.countdown.set(countDownValue);
-                });
-            }),
-          )
-        : request$.pipe(
-            catchError((err: any) => {
-              if (err instanceof HttpErrorResponse) {
-                this.error.set(true);
-                return this.handleError(err);
-              }
-              return throwError(() => err);
-            })
-          );
-
-    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.set(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 };
-  }
-
-  private handleError(error: Response | any) {
-    this.error.set(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,
-    });
-    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,
-    });
-    this.toastMessage.toastMessage(displaySuccess);
-  }
-
-  private stopPolling() {
-    this.isPending.set(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);
-  }
-}