@codex-ts/core-lib 1.0.0 → 1.0.1

package/src/lib/services/http-utility.service.ts

@@ -1,389 +0,0 @@
-import { Injectable } from '@angular/core';
-import { HttpClient, HttpParams, HttpHeaders, HttpErrorResponse, HttpEvent } from '@angular/common/http';
-import { Observable, throwError, BehaviorSubject, finalize, forkJoin } from 'rxjs';
-import { catchError, retry, timeout } from 'rxjs/operators';
-import { MessageService } from 'primeng/api';
-
-/**
- * A general-purpose HTTP utility service that provides enhanced HTTP operations
- * beyond the standard Angular HttpClient. This service includes features such as:
- * - Loading state management
- * - Standardized error handling
- * - Request timeouts and retries
- * - File upload capabilities
- * - Batch request handling
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class HttpUtilityService {
-  private loading = new BehaviorSubject<boolean>(false);
-  loading$ = this.loading.asObservable();
-
-  constructor(
-    private http: HttpClient,
-    private messageService?: MessageService
-  ) {}
-
-  /**
-   * Perform a GET request with enhanced options
-   * @param url The endpoint URL
-   * @param options Additional request options
-   * @returns An observable of the response
-   */
-  get<T>(url: string, options?: {
-    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>,
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    responseType?: 'json',
-    withCredentials?: boolean,
-    retries?: number,
-    timeoutMs?: number
-  }): Observable<T> {
-    this.loading.next(true);
-    
-    let request$ = this.http.get<T>(url, {
-      params: options?.params,
-      headers: options?.headers,
-      responseType: options?.responseType as 'json',
-      withCredentials: options?.withCredentials
-    });
-    
-    if (options?.retries) {
-      request$ = request$.pipe(retry(options.retries));
-    }
-    
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-
-  /**
-   * Perform a POST request with enhanced options
-   * @param url The endpoint URL
-   * @param body The request payload
-   * @param options Additional request options
-   * @returns An observable of the response
-   */
-  post<T>(url: string, body: any, options?: {
-    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>,
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    responseType?: 'json',
-    withCredentials?: boolean,
-    retries?: number,
-    timeoutMs?: number
-  }): Observable<T> {
-    this.loading.next(true);
-    
-    let request$ = this.http.post<T>(url, body, {
-      params: options?.params,
-      headers: options?.headers,
-      responseType: options?.responseType as 'json',
-      withCredentials: options?.withCredentials
-    });
-    
-    if (options?.retries) {
-      request$ = request$.pipe(retry(options.retries));
-    }
-    
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-
-  /**
-   * Perform a PUT request with enhanced options
-   * @param url The endpoint URL
-   * @param body The request payload
-   * @param options Additional request options
-   * @returns An observable of the response
-   */
-  put<T>(url: string, body: any, options?: {
-    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>,
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    responseType?: 'json',
-    withCredentials?: boolean,
-    retries?: number,
-    timeoutMs?: number
-  }): Observable<T> {
-    this.loading.next(true);
-    
-    let request$ = this.http.put<T>(url, body, {
-      params: options?.params,
-      headers: options?.headers,
-      responseType: options?.responseType as 'json',
-      withCredentials: options?.withCredentials
-    });
-    
-    if (options?.retries) {
-      request$ = request$.pipe(retry(options.retries));
-    }
-    
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-
-  /**
-   * Perform a DELETE request with enhanced options
-   * @param url The endpoint URL
-   * @param options Additional request options
-   * @returns An observable of the response
-   */
-  delete<T>(url: string, options?: {
-    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>,
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    responseType?: 'json',
-    withCredentials?: boolean,
-    retries?: number,
-    timeoutMs?: number
-  }): Observable<T> {
-    this.loading.next(true);
-    
-    let request$ = this.http.delete<T>(url, {
-      params: options?.params,
-      headers: options?.headers,
-      responseType: options?.responseType as 'json',
-      withCredentials: options?.withCredentials
-    });
-    
-    if (options?.retries) {
-      request$ = request$.pipe(retry(options.retries));
-    }
-    
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-  
-  /**
-   * Upload a file with optional additional data
-   * @param url The upload endpoint URL
-   * @param file The file to upload
-   * @param additionalData Additional form data to include
-   * @param options Additional request options
-   * @returns An observable of the response
-   */
-  uploadFile<T>(url: string, file: File, additionalData?: Record<string, any>, options?: {
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    withCredentials?: boolean,
-    retries?: number,
-    timeoutMs?: number,
-    onProgress?: (percentage: number) => void
-  }): Observable<T> {
-    this.loading.next(true);
-    
-    const formData = new FormData();
-    formData.append('file', file, file.name);
-    
-    if (additionalData) {
-      Object.keys(additionalData).forEach(key => {
-        formData.append(key, additionalData[key]);
-      });
-    }
-    
-    let httpOptions: any = {
-      headers: options?.headers,
-      withCredentials: options?.withCredentials
-    };
-    
-    // If progress tracking is requested
-    if (options?.onProgress) {
-      httpOptions.reportProgress = true;
-      httpOptions.observe = 'events';
-    }
-    
-    // Create the request
-    let request$ = this.http.post<any>(url, formData, httpOptions);
-    
-    // Add retries if specified
-    if (options?.retries) {
-      request$ = request$.pipe(retry(options.retries));
-    }
-    
-    // Add timeout if specified
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    // Track progress if a callback is provided
-    if (options?.onProgress) {
-      return new Observable<T>(observer => {
-        request$.subscribe({
-          next: (event: HttpEvent<any>) => {
-            if (event.type === 1 && event.total) { // HttpEventType.UploadProgress
-              const percentDone = Math.round(100 * event.loaded / event.total);
-              options.onProgress!(percentDone);
-            } else if (event.type === 4) { // HttpEventType.Response
-              observer.next(event.body);
-              observer.complete();
-            }
-          },
-          error: (error) => {
-            observer.error(this.handleError(error));
-            this.loading.next(false);
-          },
-          complete: () => {
-            this.loading.next(false);
-          }
-        });
-      });
-    }
-    
-    // Standard request without progress tracking
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    ) as Observable<T>;
-  }
-
-  /**
-   * Execute multiple HTTP requests in parallel
-   * @param requests Array of HTTP request observables
-   * @returns An observable that emits when all requests complete
-   */
-  batchRequests<T>(requests: Observable<T>[]): Observable<T[]> {
-    this.loading.next(true);
-    return forkJoin(requests).pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-  
-  /**
-   * Download a file from the server
-   * @param url The file URL
-   * @param filename Optional filename to save as
-   * @param options Additional request options
-   */
-  downloadFile(url: string, filename?: string, options?: {
-    params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>,
-    headers?: HttpHeaders | Record<string, string | string[]>,
-    withCredentials?: boolean,
-    timeoutMs?: number
-  }): Observable<Blob> {
-    this.loading.next(true);
-    
-    let request$ = this.http.get(url, {
-      params: options?.params,
-      headers: options?.headers,
-      responseType: 'blob',
-      withCredentials: options?.withCredentials
-    });
-    
-    if (options?.timeoutMs) {
-      request$ = request$.pipe(timeout(options.timeoutMs));
-    }
-    
-    return request$.pipe(
-      catchError(this.handleError.bind(this)),
-      finalize(() => this.loading.next(false))
-    );
-  }
-
-  /**
-   * Create parameter string from an object
-   * @param params Object containing parameters
-   * @returns HttpParams object
-   */
-  createParams(params: Record<string, any>): HttpParams {
-    let httpParams = new HttpParams();
-    
-    Object.keys(params).forEach(key => {
-      const value = params[key];
-      if (value !== undefined && value !== null) {
-        httpParams = httpParams.append(key, value.toString());
-      }
-    });
-    
-    return httpParams;
-  }
-
-  /**
-   * Standardized error handler for HTTP requests
-   * @param error The HTTP error
-   * @returns An observable that errors with the processed error object
-   */
-  private handleError(error: HttpErrorResponse) {
-    console.error('An HTTP error occurred:', error);
-    
-    let errorMessage = 'An error occurred';
-    let errorCode: string | undefined;
-    
-    if (error.error instanceof ErrorEvent) {
-      // Client-side error
-      errorMessage = error.error.message;
-    } else {
-      // Server-side error
-      errorCode = error.status.toString();
-      
-      switch (error.status) {
-        case 400:
-          errorMessage = error.error?.message || 'Bad request';
-          break;
-        case 401:
-          errorMessage = 'Unauthorized';
-          break;
-        case 403:
-          errorMessage = 'Access denied';
-          break;
-        case 404:
-          errorMessage = 'Resource not found';
-          break;
-        case 408:
-          errorMessage = 'Request timeout';
-          break;
-        case 500:
-          errorMessage = 'Server error';
-          break;
-        case 503:
-          errorMessage = 'Service unavailable';
-          break;
-        default:
-          errorMessage = error.error?.message || `Error ${error.status}`;
-          break;
-      }
-    }
-
-    this.showError(errorMessage);
-    return throwError(() => ({
-      error,
-      message: errorMessage,
-      code: errorCode
-    }));
-  }
-
-  /**
-   * Display an error message using the message service
-   * @param message Error message to display
-   */
-  private showError(message: string) {
-    if (this.messageService) {
-      this.messageService.add({
-        severity: 'error',
-        summary: 'Error',
-        detail: message,
-        life: 3000
-      });
-    }
-  }
-}

package/src/lib/services/notification.service.ts

@@ -1,35 +0,0 @@
-import { Injectable } from '@angular/core';
-import { MessageService } from 'primeng/api';
-import { BehaviorSubject } from 'rxjs';
-
-@Injectable()
-export class NotificationService {
-  private messageSubject = new BehaviorSubject<any>(null);
-  message$ = this.messageSubject.asObservable();
-
-  constructor(private messageService: MessageService) {}
-
-  showSuccess(message: string) {
-    const msgObj = {
-      severity: 'success',
-      summary: 'Success',
-      detail: message,
-      life: 3000
-    };
-    this.messageSubject.next(msgObj);
-  }
-
-  showError(message: string) {
-    const msgObj = {
-      severity: 'error',
-      summary: 'Error',
-      detail: message,
-      life: 3000
-    };
-    this.messageSubject.next(msgObj);
-  }
-
-  clearMessage() {
-    this.messageSubject.next(null);
-  }
-}

package/src/lib/services/reference-data-provider.service.ts

@@ -1,28 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class ReferenceDataProviderService {
-
-  private endpoints: Record<string, string> = {};
-
-  // Method to set/update endpoints
-  setEndpoints(endpoints: Record<string, string>) {
-    this.endpoints = { ...this.endpoints, ...endpoints };
-  }
-
-  getReferenceEndpoint(entityName: string): string | null {
-    console.log('getReferenceEndpoint', entityName, this.endpoints);
-    let endpoint = this.endpoints[entityName];
-    if (endpoint != null && endpoint.length > 0) {
-      if (endpoint.startsWith('http://') || endpoint.startsWith('https://')) {
-        return endpoint; // Absolute URL
-      } else {
-        // Relative URL, assume it's within the application's base context
-        return endpoint;
-      }
-    }
-    return null;
-  }
-}

package/src/lib/services/utils.service.ts

@@ -1,154 +0,0 @@
-import { Injectable } from '@angular/core';
-import { MessageService } from 'primeng/api';
-
-/**
- * A utility service that provides common reusable functionality
- * such as UUID validation and error message display
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class UtilsService {
-  /**
-   * Validates if a string is a valid UUID
-   * @param uuid The string to validate
-   * @returns boolean indicating if the string is a valid UUID
-   */
-  isValidUUID(uuid: string): boolean {
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    return uuidRegex.test(uuid);
-  }
-
-  /**
-   * Shows an error message using PrimeNG's MessageService
-   * @param message The error message to display
-   * @param messageService The MessageService instance to use
-   */
-  showError(message: string, messageService?: MessageService) {
-    if (messageService) {
-      messageService.add({
-        severity: 'error',
-        summary: 'Error',
-        detail: message,
-        life: 3000
-      });
-    }
-  }
-
-  /**
-   * Shows a success message using PrimeNG's MessageService
-   * @param message The success message to display
-   * @param messageService The MessageService instance to use
-   */
-  showSuccess(message: string, messageService?: MessageService) {
-    if (messageService) {
-      messageService.add({
-        severity: 'success',
-        summary: 'Success',
-        detail: message,
-        life: 3000
-      });
-    }
-  }
-
-  /**
-   * Gets the display value for an enum key or array of enum keys
-   * @param enumType The enum type
-   * @param key The enum key or array of enum keys
-   * @returns The display value for the enum key or comma-separated list of display values for array of keys
-   */
-  getEnumValue<T>(enumType: T, key: string | string[]): string {
-    if (!key) return '';
-    
-    if (Array.isArray(key)) {
-      // Handle array of keys - map each to its display value and join with comma
-      return key.map(k => (enumType as any)[k] || k).join(', ');
-    }
-    
-    // Handle single key
-    return (enumType as any)[key] || key;
-  }
-
-  /**
-   * Gets all values from an enum type for use in formly select fields
-   * @param enumType The enum type to get values from
-   * @returns Array of {label, value} pairs for formly select options
-   */
-  getEnumValues<T extends { [key: string]: string | number }>(enumType: T): Array<{label: string, value: string}> {
-    return Object.entries(enumType)
-      .filter(([key]) => isNaN(Number(key))) // Filter out reverse mappings
-      .map(([key, value]) => ({
-        value: key,  // enum key as the value
-        label: value as string  // enum value as the label
-      }));
-  }
-
-  /**
-   * Converts a camelCase string to Title Case with spaces
-   * @param camelCase The camelCase string to convert
-   * @returns The Title Case string
-   */
-  camelCaseToTitleCase(camelCase: string): string {
-    if (!camelCase) return '';
-    const spacedString = camelCase.replace(/([a-z])([A-Z])/g, '$1 $2');
-    return spacedString.charAt(0).toUpperCase() + spacedString.slice(1);
-  }
-
-  /**
-   * Converts a string to kebab-case
-   * @param input The string to convert
-   * @returns The kebab-case string
-   */
-  toKebabCase(input: string): string {
-    return input
-      .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-      .replace(/([A-Z])([A-Z])(?=[a-z])/g, '$1-$2')
-      .toLowerCase();
-  }
-
-  /**
-   * Converts a string to camelCase.
-   * Example: "loan-application" becomes "loanApplication"
-   * @param input The string to convert
-   * @returns The camelCase string
-   */
-  toCamelCase(input: string): string {
-    if (!input) return '';
-    
-    // Split by non-alphanumeric chars
-    const words = input.split(/[^a-zA-Z0-9]/);
-    const result = [words[0].toLowerCase()];
-    
-    // Capitalize first letter of remaining words
-    for (let i = 1; i < words.length; i++) {
-      const word = words[i];
-      if (word) {
-        result.push(word.charAt(0).toUpperCase() + word.substring(1).toLowerCase());
-      }
-    }
-    
-    return result.join('');
-  }
-
-  /**
-   * Removes double forward slashes from an endpoint string while preserving the protocol
-   * e.g. "http://localhost:8080//api//v1//users" -> "http://localhost:8080/api/v1/users"
-   * @param endpoint The endpoint string to clean
-   * @returns The cleaned endpoint string without double slashes
-   */
-  removeDoubleSlashes(endpoint: string): string {
-    if (!endpoint) return '';
-    
-    // Split the URL into protocol and the rest to preserve protocol slashes
-    const [protocol, ...rest] = endpoint.split('://');
-    
-    if (!rest.length) {
-      // If no protocol is present, just clean the entire string
-      return endpoint.replace(/\/+/g, '/');
-    }
-    
-    // Clean the path part (after protocol) and reconstruct the URL
-    const cleanPath = rest.join('://').replace(/\/+/g, '/');
-    return `${protocol}://${cleanPath}`;
-  }
-}