http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/utils/encryption/symmetrical-encryption.service.ts

@@ -1,106 +0,0 @@
-import { Injectable, inject } from '@angular/core';
-import * as CryptoJS from 'crypto-js';
-
-import { RandomSignature } from './random';
-import { AppService } from '../app.service';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class SymmetricalEncryptionService {
-
-  appID: string; // APP SERVICE TO MANAGER ENCRYPTION KEY
-
-  private appService = inject(AppService)
-
-  constructor() {
-    // TODO: The APP ID is not a string, it is a function
-    this.appID = (this.appService.appID) ? this.appService.appID : ''
-    if(this.appID === '') console.warn('No App Key has been define')
-  }
-
-  generateCipherKey() {
-    return (RandomSignature().toString() + RandomSignature().toString()).substring(0, 8)
-  }
-
-  encrypt(str: any, key = this.appID) {
-
-    if(!str || key === '') return ''
-
-    let _key = CryptoJS.enc.Utf8.parse(key)
-    let _iv = CryptoJS.enc.Utf8.parse(key)
-
-    try {
-
-    const encrypted = CryptoJS.AES.encrypt(
-      JSON.stringify(str), _key, {
-        keySize: 16,
-        iv: _iv,
-        mode: CryptoJS.mode.ECB,
-        padding: CryptoJS.pad.Pkcs7
-      });
-
-      return encrypted.toString()
-
-    } catch(error: any) {
-      console.log(error)
-    }
-
-    return
-  }
-
-  decrypt(str: string, key = this.appID) {
-
-    if(!str || key === '') return null
-
-    let _key = CryptoJS.enc.Utf8.parse(key)
-    let _iv = CryptoJS.enc.Utf8.parse(key)
-
-    try {
-
-    const decrypted = CryptoJS.AES.decrypt(
-      str, _key, {
-        keySize: 16,
-        iv: _iv,
-        mode: CryptoJS.mode.ECB,
-        padding: CryptoJS.pad.Pkcs7
-      });
-
-      // Check if the decrypted data is valid before converting to UTF-8
-      const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
-      if (!decryptedStr) {
-        console.warn('Decryption resulted in empty string');
-        return null;
-      }
-
-      return decryptedStr;
-
-    } catch(error: any) {
-      const message = String(error?.message || '');
-      if (message && !message.includes('Malformed UTF-8 data')) {
-        console.warn('Decryption failed');
-      }
-      return null;
-    }
-
-    return null;
-  }
-
-  createSignature(url: string, len = 16) {
-    const sig = CryptoJS.SHA256(url).toString(CryptoJS.enc.Hex)
-    return sig.substring(0, len).toUpperCase()
-  }
-
-  normalizeURL(url: string) {
-    const normalizedURL = url.replace(/(https?:\/\/)?(www\.)?/, '').replace(/\/+$/, '');
-    return normalizedURL;
-  }
-
-  generateSignature(url: string) {
-    const normalizedURL = this.normalizeURL(url)
-    const hash = CryptoJS.SHA256(normalizedURL)
-    const signature = hash.toString(CryptoJS.enc.Hex)
-    return signature;
-  }
-
-}

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

@@ -1,80 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { HttpHeaders } from '@angular/common/http';
-import { HeadersService } from './headers.service';
-
-describe('HeadersService', () => {
-  let service: HeadersService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [HeadersService]
-    });
-    service = TestBed.inject(HeadersService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should generate headers correctly', () => {
-    service.headers = { 'Content-Type': 'application/json' };
-    const customHeaders = { 'Authorization': 'Bearer token' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('application/json');
-    expect(result.headers.get('Authorization')).toBe('Bearer token');
-  });
-
-  it('should override default headers with custom headers', () => {
-    service.headers = { 'Content-Type': 'application/json' };
-    const customHeaders = { 'Content-Type': 'text/plain' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('text/plain');
-  });
-
-  it('should handle empty custom headers', () => {
-    service.headers = { 'Content-Type': 'application/json' };
-    const customHeaders = {};
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('application/json');
-  });
-
-  it('should handle empty default headers', () => {
-    service.headers = {};
-    const customHeaders = { 'Content-Type': 'text/plain' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('text/plain');
-  });
-
-  it('should merge multiple headers correctly', () => {
-    service.headers = { 'Content-Type': 'application/json', 'Accept': 'application/json' };
-    const customHeaders = { 'Authorization': 'Bearer token', 'Accept': 'text/plain' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('application/json');
-    expect(result.headers.get('Authorization')).toBe('Bearer token');
-    expect(result.headers.get('Accept')).toBe('text/plain');
-  });
-
-  it('should handle no headers', () => {
-    service.headers = {};
-    const customHeaders = {};
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.keys().length).toBe(0);
-  });
-
-  it('should prioritize custom headers over default headers', () => {
-    service.headers = { 'Content-Type': 'application/json', 'Authorization': 'Bearer defaultToken' };
-    const customHeaders = { 'Authorization': 'Bearer customToken' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('application/json');
-    expect(result.headers.get('Authorization')).toBe('Bearer customToken');
-  });
-
-  it('should add new custom headers to default headers', () => {
-    service.headers = { 'Content-Type': 'application/json' };
-    const customHeaders = { 'Authorization': 'Bearer token', 'Accept': 'application/xml' };
-    const result = service.generateHeaders(customHeaders);
-    expect(result.headers.get('Content-Type')).toBe('application/json');
-    expect(result.headers.get('Authorization')).toBe('Bearer token');
-    expect(result.headers.get('Accept')).toBe('application/xml');
-  });
-});

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

@@ -1,18 +0,0 @@
-import { HttpHeaders } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class HeadersService {
-
-  headers = {}
-
-  generateHeaders(headers?: Record<string, string>): { headers: HttpHeaders } {
-
-    const allHeaders = headers ? { ...this.headers, ...headers } : {}
-    return { headers: new HttpHeaders(allHeaders) }
-
-  }
-
-}

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

@@ -1,9 +0,0 @@
-export * from './app.service';
-export * from './headers.service';
-export * from './path-query.service';
-export * from './utils.service';
-export * from './random-color.utils';
-export * from './encryption/index';
-export * from './logger.service';
-export * from './models/index';
-

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

@@ -1,90 +0,0 @@
-import { Injectable, isDevMode } from '@angular/core';
-
-/**
- * LoggerService for http-request-manager library
- *
- * Automatically enables debug logging in development mode,
- * disables it in production mode.
- *
- * Usage:
- * ```typescript
- * constructor(private logger: LoggerService) {}
- *
- * this.logger.debug('WebSocket', 'Connected successfully');
- * this.logger.info('HTTP', 'Request completed', { status: 200 });
- * this.logger.warn('State', 'Cache miss for key', { key: 'user' });
- * this.logger.error('Database', 'Connection failed', error);
- * ```
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class LoggerService {
-  private static readonly DEBUG_FLAG_KEY = 'HTTP_MGR_DEBUG';
-  private debugMode: boolean;
-
-  constructor() {
-    this.debugMode = isDevMode() && this.isDebugFlagEnabled();
-  }
-
-  /**
-   * Debug level logging - only shown in development mode
-   * Use for: Detailed diagnostic information, state changes, connection events
-   */
-  debug(context: string, message: string, data?: any): void {
-    if (this.debugMode) {
-      console.log(`[HTTP-MGR DEBUG] ${context}: ${message}`, data ?? '');
-    }
-  }
-
-  /**
-   * Info level logging - only shown in development mode
-   * Use for: Important operational messages, successful operations
-   */
-  info(context: string, message: string, data?: any): void {
-    if (this.debugMode) {
-      console.info(`[HTTP-MGR INFO] ${context}: ${message}`, data ?? '');
-    }
-  }
-
-  /**
-   * Warning level logging - always shown
-   * Use for: Potential issues, deprecated usage, recoverable errors
-   */
-  warn(context: string, message: string, data?: any): void {
-    console.warn(`[HTTP-MGR WARN] ${context}: ${message}`, data ?? '');
-  }
-
-  /**
-   * Error level logging - always shown
-   * Use for: Actual errors, failures, exceptions
-   */
-  error(context: string, message: string, data?: any): void {
-    console.error(`[HTTP-MGR ERROR] ${context}: ${message}`, data ?? '');
-  }
-
-  /**
-   * Check if debug mode is enabled (development mode)
-   */
-  isDebugEnabled(): boolean {
-    return this.debugMode;
-  }
-
-  private isDebugFlagEnabled(): boolean {
-    try {
-      if (typeof globalThis === 'undefined' || !globalThis.localStorage) {
-        return true;
-      }
-
-      const value = globalThis.localStorage.getItem(LoggerService.DEBUG_FLAG_KEY);
-      if (value === null) {
-        return true;
-      }
-
-      const normalized = value.trim().toLowerCase();
-      return !['0', 'false', 'off', 'no'].includes(normalized);
-    } catch {
-      return true;
-    }
-  }
-}

package/src/lib/services/utils/models/index.ts

@@ -1,4 +0,0 @@
-export * from './normalized-request-options.model';
-export * from './path-tracker-state.model';
-export * from './query-tracker-state.model';
-export * from './query-params-tracker-options.model';

package/src/lib/services/utils/models/normalized-request-options.model.ts

@@ -1,24 +0,0 @@
-export type QueryValue = string;
-export type NormalizedQueryParams = Record<string, QueryValue>;
-
-export interface NormalizedRequestOptionsInterface {
-  pathKey: string;
-  query: NormalizedQueryParams;
-  hasQuery: boolean;
-}
-
-export class NormalizedRequestOptionsModel implements NormalizedRequestOptionsInterface {
-  constructor(
-    public pathKey: string = '',
-    public query: NormalizedQueryParams = {},
-    public hasQuery: boolean = false
-  ) {}
-
-  static adapt(item?: any): NormalizedRequestOptionsModel {
-    return new NormalizedRequestOptionsModel(
-      item?.pathKey,
-      item?.query,
-      item?.hasQuery
-    );
-  }
-}

package/src/lib/services/utils/models/path-tracker-state.model.ts

@@ -1,20 +0,0 @@
-import { QueryValue } from './normalized-request-options.model';
-
-export interface PathTrackerStateInterface {
-  watchExpiresAt?: number;
-  consumedValuesByKey: Record<string, QueryValue[]>;
-}
-
-export class PathTrackerStateModel implements PathTrackerStateInterface {
-  constructor(
-    public consumedValuesByKey: Record<string, QueryValue[]> = {},
-    public watchExpiresAt?: number
-  ) {}
-
-  static adapt(item?: any): PathTrackerStateModel {
-    return new PathTrackerStateModel(
-      item?.consumedValuesByKey && typeof item.consumedValuesByKey === 'object' ? item.consumedValuesByKey : {},
-      item?.watchExpiresAt
-    );
-  }
-}

package/src/lib/services/utils/models/query-params-tracker-options.model.ts

@@ -1,24 +0,0 @@
-export interface QueryParamsTrackerOptionsInterface {
-  mode?: 'exact' | 'variation';
-  watchParams?: string[];
-  watchExpiresAt?: string | number;
-  watchParamsExpire?: string | number;
-}
-
-export class QueryParamsTrackerOptionsModel implements QueryParamsTrackerOptionsInterface {
-  constructor(
-    public mode?: 'exact' | 'variation',
-    public watchParams?: string[],
-    public watchExpiresAt?: string | number,
-    public watchParamsExpire?: string | number
-  ) {}
-
-  static adapt(item?: any): QueryParamsTrackerOptionsModel {
-    return new QueryParamsTrackerOptionsModel(
-      item?.mode,
-      Array.isArray(item?.watchParams) ? item.watchParams : [],
-      item?.watchExpiresAt,
-      item?.watchParamsExpire
-    );
-  }
-}

package/src/lib/services/utils/models/query-tracker-state.model.ts

@@ -1,23 +0,0 @@
-import { PathTrackerStateInterface, PathTrackerStateModel } from './path-tracker-state.model';
-
-export interface QueryTrackerStateInterface {
-  paths: Record<string, PathTrackerStateInterface>;
-}
-
-export class QueryTrackerStateModel implements QueryTrackerStateInterface {
-  constructor(
-    public paths: Record<string, PathTrackerStateInterface> = {}
-  ) {}
-
-  static adapt(item?: any): QueryTrackerStateModel {
-    const paths: Record<string, PathTrackerStateInterface> = {};
-
-    if (item?.paths && typeof item.paths === 'object') {
-      Object.keys(item.paths).forEach((key) => {
-        paths[key] = PathTrackerStateModel.adapt(item.paths[key]);
-      });
-    }
-
-    return new QueryTrackerStateModel(paths);
-  }
-}

package/src/lib/services/utils/object-merger.service.spec.ts

@@ -1,18 +0,0 @@
-/* tslint:disable:no-unused-variable */
-
-import { TestBed, inject } from '@angular/core/testing';
-import { HttpClientTestingModule } from '@angular/common/http/testing';
-import { ObjectMergerService } from './object-merger.service';
-
-describe('Service: ObjectMerger', () => {
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      imports: [HttpClientTestingModule],
-      providers: [ObjectMergerService]
-    });
-  });
-
-  it('should ...', inject([ObjectMergerService], (service: ObjectMergerService) => {
-    expect(service).toBeTruthy();
-  }));
-});

package/src/lib/services/utils/object-merger.service.ts

@@ -1,78 +0,0 @@
-import { Inject, Injectable, Optional, inject } from '@angular/core';
-
-import { ApiRequest } from '../request-manager-state-service/models';
-import { SettingOptions } from '../local-storage-manager-service';
-import { UtilsService } from './utils.service';
-
-import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
-import { ConfigHTTPOptions, ConfigOptions, LocalStorageOptions } from '../request-manager-services';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class ObjectMergerService {
-
-  utils = inject(UtilsService);
-
-  constructor(@Inject(CONFIG_SETTINGS_TOKEN) @Optional() private configOptions?: ConfigOptions) {
-      if (!this.configOptions) this.configOptions = ConfigOptions.adapt()
-   }
-
-  mergeOptions(options = ApiRequest.adapt()) {
-
-    const configForRoot = (this.configOptions?.httpRequestOptions) ? this.configOptions.httpRequestOptions : ConfigHTTPOptions.adapt()
-    const mergedOptions = ApiRequest.adapt(options)
-
-    mergedOptions.server = (options && options.server === '') ? configForRoot?.server || '' : options.server
-
-    mergedOptions.path = [ ...options.path || [], ...configForRoot?.path || [] ]
-
-    mergedOptions.headers = { ...options.headers || {}, ...configForRoot?.headers || {} }
-
-    mergedOptions.retry = (options && (options?.retry?.times !== 0 || options?.retry?.delay !== 3)) ? options.retry : configForRoot?.retry || { times: 0, delay: 3 };
-
-    mergedOptions.polling = (options && options?.polling !== 0) ? options.polling : configForRoot?.polling || 0;
-
-    mergedOptions.displayError = (options && options?.displayError) ? options.displayError : configForRoot?.displayError || false;
-
-    mergedOptions.stream = (options && options?.stream) ? options.stream : configForRoot?.stream || false;
-
-    return mergedOptions;
-
-  }
-
-  mergeStorageOptions(options = SettingOptions.adapt()) {
-
-    const configForRoot = (this.configOptions?.LocalStorageOptions) ? this.configOptions.LocalStorageOptions : LocalStorageOptions.adapt()
-    const configForRootOptions = configForRoot.options || LocalStorageOptions.adapt().options
-
-    const mergedOptions = SettingOptions.adapt(options)
-
-    // storage type
-    mergedOptions.storage = (options && (typeof options.storage !== 'undefined')) ? options.storage : (configForRootOptions?.storage ?? 0)
-
-    // expires: prefer explicit numeric expires; if not provided, compute from expiresIn string; otherwise use config default
-    // if an explicit, non-zero numeric expires is provided, use it
-    if (options && (typeof options.expires !== 'undefined') && options.expires !== null && Number(options.expires) > 0) {
-      mergedOptions.expires = Number(options.expires);
-    } else if (options && options.expiresIn) {
-      // compute numeric epoch from expiresIn string using UtilsService if available
-      try {
-        mergedOptions.expires = this.utils ? this.utils.expires(options.expiresIn) : 0;
-      } catch {
-        mergedOptions.expires = 0;
-      }
-    } else {
-      mergedOptions.expires = configForRootOptions?.expires ?? 0;
-    }
-
-    // keep expiresIn string if explicitly provided, otherwise use config default
-    mergedOptions.expiresIn = (options && (typeof options.expiresIn !== 'undefined')) ? options.expiresIn : (configForRootOptions?.expiresIn || '')
-
-    mergedOptions.encrypted = (options && (typeof options.encrypted !== 'undefined')) ? options.encrypted : (configForRootOptions?.encrypted || false)
-
-    return mergedOptions;
-
-  }
-
-}

package/src/lib/services/utils/path-query.service.spec.ts

@@ -1,117 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { PathQueryService } from './path-query.service';
-
-describe('PathQueryService', () => {
-  let service: PathQueryService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      providers: [PathQueryService]
-    });
-    service = TestBed.inject(PathQueryService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  it('should build API path with only server', () => {
-    const result = service.buildAPIPath('http://example.com');
-    expect(result).toBe('http://example.com');
-  });
-
-  it('should build API path with server and path params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource']);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should build API path with server, path params, and query params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', { query: 'value' }]);
-    expect(result).toBe('http://example.com/path/to/resource?query=value');
-  });
-
-  it('should build API path with server and query params', () => {
-    const result = service.buildAPIPath('http://example.com', [{ query: 'value' }]);
-    expect(result).toBe('http://example.com?query=value');
-  });
-
-  it('should handle empty query params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', {}]);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should remove empty query params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', { query: '' }]);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should clean URL path', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', '', 'to', 'resource']);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should handle null query params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', null]);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should handle undefined query params', () => {
-    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', undefined]);
-    expect(result).toBe('http://example.com/path/to/resource');
-  });
-
-  it('should build API path with server as string array and path params', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource']);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should build API path with server as string array, path params, and query params', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: 'value' }]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value');
-  });
-
-  it('should build API path with server as string array and query params', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], [{ query: 'value' }]);
-    expect(result).toBe('http://example.com/api/v1?query=value');
-  });
-
-  it('should handle empty query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', {}]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should remove empty query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: '' }]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should clean URL path with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', '', 'to', 'resource']);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should handle null query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', null]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should handle undefined query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', undefined]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource');
-  });
-
-  it('should handle multiple query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query1: 'value1', query2: 'value2' }]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource?query1=value1&query2=value2');
-  });
-
-  it('should handle array query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: ['value1', 'value2'] }]);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value1%2Cvalue2');
-  });
-
-  it('should handle mixed path and query params with server as string array', () => {
-    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', { query: 'value' }, 'to', 'resource']);
-    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value');
-  });
-});