http-request-manager 15.0.24 → 15.0.26

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

@@ -0,0 +1,282 @@
+import { Injectable } from '@angular/core';
+
+import { BehaviorSubject, EMPTY, Observable, from, of } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AsymmetricalEncryptionService {
+
+  constructor() {}
+
+  generateKeyPair(modulusLength = 2048): Observable<CryptoKeyPair> {
+  
+    // modulusLength - 1024, 2048, 4096
+    // hash - SHA-256
+
+   return from(crypto.subtle.generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength,
+        publicExponent: new Uint8Array([1, 0, 1]), // 65537
+        hash: { name: "SHA-256" }
+      },
+      true, // Extractable keys
+      ["encrypt", "decrypt"]
+    ))
+
+  }
+
+  encryptData(publicKey: CryptoKey, data: string) {
+
+    const encodedData = new TextEncoder().encode(data)
+
+    return from(crypto.subtle.encrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      publicKey,
+      encodedData
+    )).pipe(
+      map(enc => this.arrayBufferToBase64(enc))
+    )
+
+  }
+
+  decryptData(privateKey: CryptoKey, encryptedData: string) {
+
+    const encStr = this.base64ToArrayBuffer(encryptedData)
+
+    return from(crypto.subtle.decrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      privateKey,
+      encStr
+    ).then(decryptedData => {
+      return new TextDecoder().decode(decryptedData)
+    }))
+
+  }
+
+  pemToArrayBuffer(pem: string): ArrayBuffer {
+
+    const b64 = pem.replace(/(-----BEGIN (RSA )?(PRIVATE|PUBLIC) KEY-----|-----END (RSA )?(PRIVATE|PUBLIC) KEY-----|\n)/g, '')
+    const binaryString = atob(b64)
+    const len = binaryString.length
+    const buffer = new ArrayBuffer(len)
+    const view = new Uint8Array(buffer)
+
+    for (let i = 0; i < len; i++) {
+      view[i] = binaryString.charCodeAt(i)
+    }
+
+    return buffer
+
+  }
+
+  base64ToArrayBuffer(base64: string): ArrayBuffer {
+    
+    const binaryString = atob(base64);
+    const len = binaryString.length;
+    const buffer = new ArrayBuffer(len);
+    const view = new Uint8Array(buffer);
+
+    for (let i = 0; i < len; i++) {
+        view[i] = binaryString.charCodeAt(i);
+    }
+
+    return buffer;
+  }
+
+  arrayBufferToBase64(buffer: ArrayBuffer): string {
+
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+
+    return window.btoa(binary)
+
+  }
+
+  base64ToPEM(base64Key: string, publicKey = true) {
+
+    const keyType = (publicKey) ? 'PUBLIC' : 'PRIVATE'
+
+    const header = `-----BEGIN ${keyType} KEY-----\n`
+    const footer = `\n-----END ${keyType} KEY-----`
+
+    const keyBody = base64Key.match(/.{1,64}/g)?.join("\n") || ""
+
+    return header + keyBody + footer
+
+  }
+
+  pemToCryptoKey(
+    pem: string, 
+    algorithm: RsaHashedKeyGenParams, 
+    extractable: boolean, 
+    keyUsages: KeyUsage[],
+    format: any = "pkcs8" //"raw" | "pkcs8" | "spki"
+    ) {
+    
+    const buffer = this.pemToArrayBuffer(pem);
+
+    console.log('buffer found ', buffer);
+    
+    return from(crypto.subtle.importKey(
+      format,
+      buffer,
+      algorithm,
+      extractable,
+      keyUsages
+    ))
+
+  }
+  
+  // TESTING
+
+  testGenerateKeys(): Observable<string> {
+    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>("");
+    const testSequence$: Observable<string> = testSequence.asObservable();
+    testSequence.next("Test Generating Keys");
+
+    // GENERATE KEYS
+    this.generateKeyPair().subscribe((data) => {
+
+      console.log("GEN-GENERATED KEYS: ", data)
+
+      crypto.subtle.exportKey('spki', data.publicKey)
+      .then(key => {
+        const publicKeyBase64 = this.arrayBufferToBase64(key);
+        console.log("GEN-EXPORT PUBLIC KEY: ", this.base64ToPEM(publicKeyBase64, true));
+      })
+
+      crypto.subtle.exportKey('pkcs8', data.privateKey)
+      .then(key => {
+        const privateKeyBase64 = this.arrayBufferToBase64(key);
+        console.log("GEN-EXPORT PRIVATE KEY: ", this.base64ToPEM(privateKeyBase64, false));
+      });
+
+      // TEST WITH GENERATED KEYS
+      this.encryptData(data.publicKey, "Sample Data here - Mike Bonifacio")
+          .subscribe((enc) => {
+
+            console.log("GEN-ENCRYPT==>: ", enc)
+
+            this.decryptData(data.privateKey, enc).subscribe((dec) => {
+              testSequence.next('Test Passed');
+              testSequence.complete();
+            })
+
+          })
+
+    })
+    return testSequence$;
+
+  }
+
+  testDecryptionWithKeys(): Observable<string> {
+    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>("");
+    const testSequence$: Observable<string> = testSequence.asObservable();
+    testSequence.next("Test Generating Keys");
+
+    const privateKey = `-----BEGIN PRIVATE KEY-----
+    MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDKVBkCWNb9eHVF
+    twAA5mdAyvXFix3WavdrsoYRkvtCl8ogDBQf8f6N0bRkDF1zcVHRrNAEyozXDtuD
+    kFgSiivBFREI7fiS3sOvduq6FaGXzX0IY6oaVMu8oOPgDvC0yvoohR+0Qxq2d6lP
+    SPyHeKQaxP4KxzCJJzB1XAcbd2eFzUUDv25mNlwdVkmW8FI/sAxnJLgPTW78dzfX
+    Ddfk+nxdIqxVKSLATnL0kMN7aGJx24UozioAIpzvvvF5/+7HTd1gi6NeCqrAYr3g
+    iP364AE26CFwFvHnafO9uNQhlQ+uiNnOoInXByfFGVP+RidSpfLzaxDjs6RDwpol
+    h098btONAgMBAAECggEAAVhHM2OD5IkUtuowwcKNaCTKGmrClRE3gMuzJeBsSJEy
+    uAReUFILZylcnhegDytSti2vDA9T7xqtO6CU0p3V8LpU89JMOPRb/deirI4UXSpx
+    xbNyjirOO6bnrNlOWfKexdQQsikYPzF2iM1Scpr1u9ZDCHZOl1ZYSrkve5My4coP
+    3Gx6tTBqL0jQBfcpf4ES8BH3JSawR/MgqzDS74+bI2VH+kvuPAC1L4fBgaV3VUv0
+    nFzim5A3s5VaXPgJbEIghP9BkYGFkeT9ma3nliEZWc96AzsmowFn1ayCvrNVPo9R
+    ECD2NnttBiCJZt3H93sR9+OTeA8Bls+aZGlKd5mLAQKBgQDpf8nIYUm/Zmls7/lQ
+    QBUSGHEYrbjNsEejQsPgNDtg2EVSxdUkvTn7Wb+HExTk09Z5bNvhaO2532/FH9y8
+    ahSXafiMXpfR2olwXdOB9yXXl4F5C0LGnmzGim4OSeWzAX0JCL470KaS0QN3EmoG
+    9F0YCfMnZXNTweSSx4xvlO6ggQKBgQDd01uIolm7z1DIWCwNERAXP2GDwcvxyzYK
+    YqJfKDeHt2t6yIzZMMotnPDy+OlcdGspIIHkB5a+SZN5Nt7DUKg/MnyOZ3KbVq41
+    k7dR4Ka3LRnGkesy7lSr7ef1rfquyR75OXJQcPWvkFcLu0TMiQhvptatZ8VN+F4n
+    fDQELRotDQKBgQCgN+AUT7VT0QjcCBnRV/ddUEoiPenFsYSmYMSYzh5ESIHg1wB2
+    0iS79Iw4Of6nOTg8X1bM57vfQ5Kk90T2P+/bKYqzfqC8DTErWiYsUpKzyTC9Bt4N
+    /Vz0Kr5zrX8ggg/yp/4oevYhXav8AzWfigNq4EDpMnKc8TlPAf+5/L50gQKBgQC2
+    mLPhPhr1gUszD3l7bA89w7uGlLFHoQoj9FtKTzWervp3QLzIT+QtNeIVb5XQuDg5
+    y3uAdEq+6pvNjMBEMJG+K9Xh9v+dJPYUPjsJ2A4D/MkZ7qWX8B2cxSJK1uLim8W2
+    S3ZxBvsGgJ9WldmlMCvUlJZkeWYtr4P5psC+q02/xQKBgQCDII/jcV2+lRM2iNTe
+    vBijZSaNMEWOK/Y+/HFK8GYKXnB+xNWhrm8rKgWGzpDJAUPMh9Tt+leW9LKEBuzF
+    Y1bGblmGm1zsPWpIx05Fdtv9eOJmFnXbGzIsYyhadZnPcQOWhqxtpVxSuul0Jc7Q
+    XNq4qPaPXhbQAshgtyBt75DMkw==
+    -----END PRIVATE KEY-----`
+    
+        const pubKey = `-----BEGIN PUBLIC KEY-----
+    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylQZAljW/Xh1RbcAAOZn
+    QMr1xYsd1mr3a7KGEZL7QpfKIAwUH/H+jdG0ZAxdc3FR0azQBMqM1w7bg5BYEoor
+    wRURCO34kt7Dr3bquhWhl819CGOqGlTLvKDj4A7wtMr6KIUftEMatnepT0j8h3ik
+    GsT+CscwiScwdVwHG3dnhc1FA79uZjZcHVZJlvBSP7AMZyS4D01u/Hc31w3X5Pp8
+    XSKsVSkiwE5y9JDDe2hicduFKM4qACKc777xef/ux03dYIujXgqqwGK94Ij9+uAB
+    NughcBbx52nzvbjUIZUProjZzqCJ1wcnxRlT/kYnUqXy82sQ47OkQ8KaJYdPfG7T
+    jQIDAQAB
+    -----END PUBLIC KEY-----`
+
+    const algorithm: RsaHashedKeyGenParams = {
+      name: "RSA-OAEP",
+      modulusLength: 2048,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    };
+
+    // ENCRYPT
+    this.pemToCryptoKey(
+      pubKey,
+      algorithm,
+      true,
+      ["encrypt"],
+      "spki"
+    ).subscribe((keyPublic) => {
+
+      // console.log("PUBLIC KEY: ", keyPublic)
+
+      this.encryptData(keyPublic, "Sample Data here - Mike Bonifacio")
+      .subscribe((str) => {
+        console.log("ENCRYPTED STRING: ", str);
+        testSequence.next('encrypted string success');
+      })
+
+    })
+
+    const enc = "r7UOuEGBZ6jbVTOIBuv9jFOEtRiedmS27hfW40k7XKCTsQ5VhWup0qu2BA2ANZaGKii/uehJ/RSPiyfGbJ6leJrat0mA1hPqH/XodaBzLMDigvdYM1NSXFZMDa40OpLUIXbPlAvybjcGu7Bal+LMA8htHrFu/OmM/fHI66xOzzpuXSYx0OkWjtY81rUQ1FFkvrkx2jGFPZ0p+Nw/v3Q4cJnet6V63vCueFlD749VMcVXo7pvz4AIPpB+IOy3kbxaYTPakLVioJERU6GFMXWkECuRvohhS9CETcORZtRVRkvhcHk3lxgIhfqojUKYgD6K5dDELDPsWIS+iTG1XIQIlg==";
+
+    // DECRYPTION
+    this.pemToCryptoKey(
+      privateKey,
+      algorithm,
+      false,
+      ["decrypt"],
+      "pkcs8"
+    ).subscribe((key) => {
+
+      // console.log("DECRYPT ===", key)
+
+      this.decryptData(key, enc)
+      .pipe(
+        catchError(err => {
+          console.log("ERROR: ", err);
+          return EMPTY
+        })
+      ).subscribe((str) => {
+        console.log("DECRYPTED STRING: ", str);
+        testSequence.next('decrypted string success');
+      })
+
+    })
+
+    return testSequence$;
+  };
+}

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/{lib/services/utils/encryption/index.d.ts → src/lib/services/utils/encryption/index.ts}

@@ -1,3 +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,69 @@
+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()
+}
+
+

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/{lib/services/utils/index.d.ts → src/lib/services/utils/index.ts}

@@ -2,4 +2,6 @@ export * from './app.service';
 export * from './headers.service';
 export * from './path-query.service';
 export * from './utils.service';
+
 export * from './encryption/index';
+

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

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

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

@@ -0,0 +1,60 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+
+import { ApiRequest } from '../request-manager-state-service/models';
+import { SettingOptions } from '../local-storage-manager-service';
+
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigHTTPOptions, ConfigOptions, LocalStorageOptions } from '../request-manager-services';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ObjectMergerService {
+
+  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)
+
+    mergedOptions.storage = (options && options.storage === 0) ? configForRootOptions?.storage || 0 : options.storage
+
+    mergedOptions.expires = (options && options.expires === 0) ? configForRootOptions?.expires || 0 : options.expires
+
+    mergedOptions.expiresIn = (options && options.expiresIn === '') ? configForRootOptions?.expiresIn || '' : options.expiresIn
+
+    mergedOptions.encrypted = (options && !options.encrypted) ? configForRootOptions?.encrypted || false : options.encrypted
+
+    return mergedOptions;
+
+  }
+
+}