http-request-manager 18.7.19 → 18.7.21

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

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

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

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

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

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

@@ -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,7 @@
+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

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

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

@@ -0,0 +1,69 @@
+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 !== "")
+    )
+
+}