http-request-manager 18.7.21 → 18.7.24

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

@@ -1,39 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class EncryptionTestService {
-
-  constructor() { }
-
-  private isBase64(str: string): boolean {
-    const base64Pattern = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
-    return base64Pattern.test(str);
-  }
-
-  private isHexadecimal(str: string): boolean {
-    const hexPattern = /^[0-9a-fA-F]+$/;
-    return hexPattern.test(str) && (str.length % 2 === 0);
-  }
-
-  private hasHighEntropy(str: string): boolean {
-    const uniqueChars = new Set(str).size;
-    return uniqueChars > str.length * 0.6;
-  }
-
-  isEncrypted(str: string): boolean {
-
-    if (typeof str !== 'string') {
-      return false;
-    }
-
-    if (this.isBase64(str) || this.isHexadecimal(str)) {
-      return true;
-    }
-
-    return this.hasHighEntropy(str);
-
-  }
-
-}

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

@@ -1,5 +0,0 @@
-export * from "./asymmetrical-encryption.service";
-export * from './symmetrical-encryption.service';
-
-export * from './random';
-

package/src/lib/services/utils/encryption/random.ts

@@ -1,81 +0,0 @@
-export const Random = () => {
-  const typedArray = new Uint8Array(1)
-  const randomValue = crypto.getRandomValues(typedArray)[0]
-  const randomFloat = randomValue / Math.pow(2, 8)
-  return randomFloat
-}
-
-export const RandomNumber = (min: number, max: number) => {
-  return Math.floor(Random() * max) + min
-}
-
-export const RandomNumbers = (min: number, max: number, length: number) => {
-  const numbers: number[] = []
-  for (let i = 0; i < length; i++) numbers.push(Math.floor(Random() * max) + min)
-  return numbers
-}
-
-export const RandomNumbersUnique = (min: number, max: number, length: number) => {
-  let count = 0;
-
-  // Adjust the length if it exceeds the number of unique numbers possible in the range
-  if (length > (max - min + 1)) {
-    console.error('error encountered');
-    length = max - min + 1;
-  }
-
-  console.log('length', length);
-  const numbers: number[] = [];
-  const maxAttempts = length * 100 ; // Safeguard to prevent infinite loops
-
-  while (numbers.length < length && count < maxAttempts) {
-
-    const num = Math.floor(Random() * max) + min;
-
-    if (!numbers.includes(num)) {
-      numbers.push(num);
-    }
-  }
-
-  if (count >= maxAttempts) {
-    throw new Error('Maximum attempts exceeded while generating unique numbers');
-  }
-
-  return numbers;
-};
-
-export const RandomStr = () => {
-
-  const typedArray = new Uint8Array(8)
-  const array = new Uint32Array(1)
-  crypto.getRandomValues(array)
-  return array[0].toString(36)
-
-}
-
-export const RandomSignature = () => {
-
-  const typedArray = new Uint8Array(8)
-  const array = new Uint32Array(1)
-  crypto.getRandomValues(array)
-  return array[0]
-
-}
-
-export const UUID = () => {
-  return self.crypto.randomUUID()
-}
-
-/**
- * Generate a UUID string (legacy format)
- */
-export const UUID_STR = (): string => {
-  const s4 = () => {
-    return Math.floor((1 + Random()) * 0x10000)
-      .toString(16)
-      .substring(1);
-  };
-  return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
-};
-
-

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

@@ -1,93 +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
-
-    let _key = CryptoJS.enc.Utf8.parse(key)
-    let _iv = CryptoJS.enc.Utf8.parse(key)
-
-    try {
-
-    return CryptoJS.AES.decrypt(
-      str, _key, {
-        keySize: 16,
-        iv: _iv,
-        mode: CryptoJS.mode.ECB,
-        padding: CryptoJS.pad.Pkcs7
-      }).toString(CryptoJS.enc.Utf8);
-
-    } catch(error: any) {
-      console.log(error)
-    }
-
-    return
-  }
-
-  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,7 +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';
-

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');
-  });
-});

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

@@ -1,69 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class PathQueryService {
-
-  buildAPIPath(server: string|string[], params?: any[]|any) {
-
-    server = (Array.isArray(server)) ? server.join('/') : server
-
-    const pathObjects = (params) ? params.filter((path:any) => (!this.isObject(path))) : []
-    const queryObjects = (params) ? params.filter((path:any) => (this.isObject(path))) : []
-
-    const query = this.removeEmptyParams(queryObjects.reduce((r: any, c: any) => {
-      Object.entries(c).forEach(([key, value]) => {
-        r[key] = Array.isArray(value) ? value.join(',') : value
-      })
-      return r
-    }, {}))
-
-    let path = this.buildRestPath(server, pathObjects)
-
-    return(Object.keys(query).length > 0) ? path + '?' + this.buildQueryPath(query) : path
-
-  }
-
-  private buildRestPath(server: string, params: any[]): string {
-    server = (server) ? server : ''
-    server = (server.charAt(0) === '/') ? server.substring(1) : server
-    return this.cleanUrlPath(server +'/'+ params.join('/'))
-  }
-
-  private buildQueryPath(params: any): string {
-
-    const searchParams = new URLSearchParams()
-
-    for (const key in params) {
-
-      if (Array.isArray(params[key])) {
-        params[key].forEach((value: any) => searchParams.append(key, value));
-      } else {
-        searchParams.append(key, params[key]);
-      }
-
-    }
-
-    return searchParams.toString()
-
-  }
-
-  private cleanUrlPath(str: string) {
-    return str.replace(/([^:]\/)\/+/g, "$1").replace(/\/$/,'')
-  }
-
-  private isObject(val: any): boolean {
-    return (val === null) ? false : ( (typeof val === 'function') || (typeof val === 'object') )
-  }
-
-  private removeEmptyParams = (obj: any): Record<string, any> =>
-    Object.fromEntries(
-      Object.entries(obj)
-        .map(([key, value]) =>
-          [key, value && typeof value === 'object' ? this.removeEmptyParams(value) : value]
-        )
-        .filter(([_, value]) => value !== undefined && value !== "")
-    )
-
-}