http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,18 @@
+/* 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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,117 @@
+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');
+  });
+});