http-request-manager 18.7.20 → 18.7.21

package/src/lib/services/request-manager-state-service/index.ts

@@ -0,0 +1,3 @@
+export * from "./http-manager-state.store";
+
+export * from "./models/index";

package/src/lib/services/request-manager-state-service/models/api-request.model.ts

@@ -0,0 +1,61 @@
+import { RetryOptions } from "../../request-manager-services"
+import { WSOptions } from "./ws-options.model"
+import { StreamType } from "./stream-type.enum"
+
+export interface ApiRequestInterface {
+  server: string
+  path?: any[]
+  headers?: any
+  adapter?: any
+  mapper?: any
+  polling?: number // seconds (undefined | 0 = none)
+  retry?: RetryOptions
+  stream?: boolean
+  streamType?: StreamType
+  displayError?: boolean
+  saveAs?: string
+  fileContentHeader?: string
+  ws?: WSOptions // Websocket Options
+}
+
+export class ApiRequest implements ApiRequestInterface {
+
+  constructor(
+    public server = '',
+    public path?: any[],
+    public headers?: any,
+    public adapter?: any,
+    public mapper?: any,
+    public polling?: number,
+    public retry?: RetryOptions,
+    public stream?: boolean,
+    public streamType?: StreamType,
+    public displayError?: boolean,
+    public saveAs?: string,
+    public fileContentHeader?: string,
+    public ws?: WSOptions,
+  ) {}
+
+  static adapt(item?: any): ApiRequest {
+
+    const server = Array.isArray(item?.server) ? item.server.join('/') : item?.server || '';
+
+    return new ApiRequest(
+      server,
+      (item?.path) ? item.path : [],
+      (item?.headers) ? item.headers : {},
+      item?.adapter,
+      item?.mapper,
+      item?.polling ? Math.floor(item.polling) : 0,
+      item?.retry ? RetryOptions.adapt(item.retry) : RetryOptions.adapt(),
+      (item?.stream) ? item.stream : false,
+      item?.streamType || StreamType.AI_STREAMING,
+      (item?.displayError) ? item.displayError : false,
+      item?.saveAs,
+      item?.fileContentHeader,
+      item?.ws,
+    )
+
+  }
+
+}

package/src/lib/services/request-manager-state-service/models/index.ts

@@ -0,0 +1,6 @@
+export * from "./api-request.model";
+export * from "./request-options.model";
+export * from "./stream-type.enum";
+
+export * from "./ws-options.model";
+

package/src/lib/services/request-manager-state-service/models/request-options.model.ts

@@ -0,0 +1,22 @@
+export interface RequestOptionsInterface {
+    path: any[],
+    headers: any,
+}
+
+export class RequestOptions implements RequestOptionsInterface {
+
+  constructor(
+    public path: any[] = [],
+    public headers = {},
+  ) {}
+
+  static adapt(item?: any): RequestOptions {
+
+    return new RequestOptions(
+      item?.path,
+      item?.headers,
+    )
+
+  }
+
+}

package/src/lib/services/request-manager-state-service/models/stream-type.enum.ts

@@ -0,0 +1,13 @@
+/**
+ * Enum representing valid streaming format types
+ * 
+ * This enum defines all supported streaming formats for HTTP requests.
+ * Each enum value corresponds to a specific data format and parsing strategy.
+ */
+export enum StreamType {
+  JSON = 'json',
+  NDJSON = 'ndjson', 
+  AI_STREAMING = 'ai_streaming',
+  EVENT_STREAM = 'event_stream',
+  AUTO = 'auto'
+}

package/src/lib/services/request-manager-state-service/models/ws-options.model.ts

@@ -0,0 +1,39 @@
+import { RetryOptions } from "../../request-manager-services"
+
+export interface WSOptionsInterface {
+    id: string,
+    wsServer: string,
+    jwtToken: string,
+    permissions?: string[],
+    channels?: string[],
+    user?: any,
+    retry?: RetryOptions
+}
+
+export class WSOptions implements WSOptionsInterface {
+
+  constructor(
+    public id: string = '',
+    public wsServer: string = '',
+    public jwtToken: string = '',
+    public permissions?: string[],
+    public channels?: string[],
+    public user?: any,
+    public retry?: RetryOptions
+  ) {}
+
+  static adapt(item?: any): WSOptions {
+
+    return new WSOptions(
+      item?.id,
+      item?.wsServer,
+      item?.jwtToken,
+      (item?.permissions) ? item.permissions.split(',').map((p: string) => p.trim()) : [],
+      item?.channels,
+      item?.user,
+      item?.retry
+    )
+
+  }
+
+}

package/src/lib/services/store-state-manager-service/index.ts

@@ -0,0 +1,3 @@
+export * from "./store-state-manager.service";
+
+export * from "./models/index";

package/src/lib/services/store-state-manager-service/models/index.ts

@@ -0,0 +1,2 @@
+export * from "./state-storage-options.model";
+

package/src/lib/services/store-state-manager-service/models/state-storage-options.model.ts

@@ -0,0 +1,24 @@
+import { SettingOptions } from "../../local-storage-manager-service";
+
+export interface StateStorageOptionsInterface {
+  store?: string;
+  options?: SettingOptions;
+  model?: (state: any) => any;
+}
+
+export class StateStorageOptions implements StateStorageOptionsInterface {
+
+  constructor(
+    public store?: string,
+    public options?: SettingOptions,
+    public model?: (state: any) => any
+  ) {}
+
+  static adapt(item?: any): StateStorageOptions {
+    return new StateStorageOptions(
+      item?.store ?? 'temp',
+      item?.options ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
+      item?.model
+    );
+  }
+}

package/src/lib/services/store-state-manager-service/store-state-manager.service.ts

@@ -0,0 +1,88 @@
+import { LocalStorageManagerService } from '../local-storage-manager-service/local-storage-manager.service';
+import { inject, Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { StateStorageOptions } from './models/state-storage-options.model';
+import { Subscription, take } from 'rxjs';
+
+export interface StateStoreManagerData<T> {}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StoreStateManagerService<T extends object = StateStoreManagerData<any>> extends ComponentStore<T> {
+
+  localStorageManagerService = inject(LocalStorageManagerService)
+
+  subscriptions = new Subscription
+  settings: any = null
+
+  private isRestoring = false
+
+  constructor(
+    private options: StateStorageOptions = StateStorageOptions.adapt()
+  ) {
+    super(StoreStateManagerService.init(options))
+    this.init(options)
+  }
+
+  private static init(options: StateStorageOptions): any {
+
+    const model = options?.model
+    return (model) ? (model as () => any)() : {}
+
+  }
+
+  init(options?: StateStorageOptions) {
+
+    this.settings = options
+
+    this.localStorageManagerService.createStore({
+      name: this.settings?.store,
+      data: this.settings?.model(),
+      options: this.settings?.options,
+    })
+
+    this.localStorageManagerService.store$(this.settings?.store)
+    .subscribe(data => this.setState(data))
+
+  }
+
+  restoreState(): Subscription {
+
+    return this.localStorageManagerService.store$(this.settings?.store)
+    .pipe(take(1))
+    .subscribe(data => {
+      this.updateData(data)
+    })
+
+  }
+
+  updateState(state: any) {
+    if(this.isRestoring) return
+    this.localStorageManagerService.updateStore({
+      name: this.settings?.store,
+      data: state
+    })
+
+  }
+
+  // Selectors
+  readonly data$ = this.select((state: any) => {
+    const model = this.options.model;
+    return (typeof model === 'function' && !model.prototype) ? model(state) : state
+  });
+
+  // Updaters
+  readonly updateData = this.updater((state, data: any) => {
+
+    const key = Object.keys(data)[0]
+    const hasKey = Object.keys(state).includes(key)
+
+    if (!hasKey) return state
+    const newState = { ...state, [key]: data[key] }
+    this.updateState(newState)
+    return { ...state, ...newState }
+
+  })
+
+}

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

@@ -0,0 +1,25 @@
+import { TestBed } from '@angular/core/testing';
+import { APP_ID } from '@angular/core';
+import { AppService } from './app.service';
+
+describe('AppService', () => {
+  let service: AppService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        AppService,
+        { provide: APP_ID, useValue: 'test-app-id' }
+      ]
+    });
+    service = TestBed.inject(AppService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should have appID assigned from APP_ID', () => {
+    expect(service.appID).toBe('test-app-id');
+  });
+});

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

@@ -0,0 +1,21 @@
+import { APP_ID, Inject, Injectable } from '@angular/core';
+
+// Must provide a value for APP_ID in AppModule->Providers
+// providers: [
+//   {
+//     provide: APP_ID,
+//     useValue: "056991ac-3537-43ab-b5b9-83edf6554eff",
+//   },
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AppService {
+
+  appID: string
+
+  constructor(@Inject(APP_ID) private id: string) {
+    this.appID = this.id
+  }
+
+}

package/src/lib/services/utils/encryption/README.md

@@ -0,0 +1,79 @@
+# Generate a Key Pair on Mac
+
+To generate a key pair on a Mac, you can use the built-in openssl command-line tool. This tool is available on most Unix-like operating systems, including macOS. Below are the steps to generate an RSA key pair using openssl:
+
+### Step 1: Open Terminal
+
+Open the Terminal application on your Mac. You can find it in the Utilities folder within the Applications folder, or you can use Spotlight to search for "Terminal".
+
+### Step 2: Generate the Private Key
+
+Run the following command to generate a 2048-bit RSA private key:
+
+```sh
+openssl genpkey -algorithm RSA -out private_key.pem -pkeyopt rsa_keygen_bits:2048
+```
+
+### Step 3: Generate the Public Key
+
+Run the following command to extract the public key from the private key:
+
+```sh
+openssl rsa -pubout -in private_key.pem -out public_key.pem
+```
+
+### Step 4: View the Keys (Optional)
+
+You can view the contents of the generated key files using the cat command:
+
+To view the private key:
+
+```sh
+cat private_key.pem
+```
+
+To view the public key:
+
+```sh
+cat public_key.pem
+```
+
+    -----BEGIN PRIVATE KEY-----
+    MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC2mvvEWn/aMikX
+    A8+/Po2R4+PHwC9wxa10fr75sR9Wbuq8NY/yY174JHR4rRmyV8EnKEfyoTzfsvTO
+    858lPD4DuUKESh+NDKiLNUdY4isrR060rxzJn+30OzKkZIHWhIZY3jqEw7C+glMV
+    Fmphtci4WQqPYwi1rX3YswE0MJhF/a+HCZ5erDmET/PFZJtTSsx47zbeck2Mnfta
+    KpF/wS9jYtpUFrf/vSuTo4Q0libauiFwPgCeYTGEBGGbKVnbAbM71qqmjOxT0ItW
+    TbsrGWG54G6vTxg/mnzxpJfMNlVOogv9u2YcG0lEQ/xo9P88WBWPdE0TK5V37GOq
+    3twvUruHAgMBAAECggEAThZZqr6OpQbFRofFO8GqtaQQAJghUWbfRY176ngBcCtP
+    azu2ek9fSdsBCafwcLERMscJeWrVBs5W3PcWa8xmsp3zIXI3KtCqdJlMkOhq0H+W
+    WzL1Kw2eqs3z2pP2Z/9VGkSyHps2hklh8QccZ/teQeMl3mpZy6NMyTHHRoOvYmIg
+    TBhDPL+WWJXPVlgKle3RRDVeD1JVo5XmsOW4I8FRyp5f7BZE1IwPTNDUATAtwC8u
+    dHHo1rTkWIk2gxVPRcH61w8ceij4VPv7Sk7iFobcLkscTwbTzondU3YssSYEmayW
+    5+qhIbHXWnn4FVMPVrDUORVAW8naCrVVBCYGWFDnQQKBgQDcsQ07EaYWDnRQ0xcq
+    5hTQUnd137CKNQcLXJ8T+ghuj5v0ZhPpu3YZDjm+rX52mrFN4+kEMKkCjFJAeKaI
+    omqKb/i57t7tcQKsbGdtUyRt7PirnHed7dlEo0ElwBWr58hTcUuTnoIiQM3sgmpn
+    VrlntlWpVWr0hoJMxRS6Pb6xQQKBgQDT0gVdNm0+ZrBKDWWKkeaQHHyxdva8Dt6C
+    NEjP+uU16hF6CsPGCvDuNA9PMIqGHR914aeEwYWtma6/zI1T74jhlUiyAHkpW373
+    +xNWmruq8k3UlVBK8JIjH/LOXNV5Gw85yLJwokhl6A8m4DSMkDJZTLVXfYQ24su1
+    TMDz0yhyxwKBgA/jNx6fgKNp2vnOmIZgFfOBXFRCDEWG18D7pAAeKek7sXCAwMI8
+    2p2nJoURnF8Rd94xoB7LGf+y9mDpzqNbfewFb5SDG81gK18aVr/KEn9PZf+Evh/C
+    dbe5QQFkuKqtfwBy0YwJBzlMDQcPxHU4CxTqTXRpT8/Wtx6ruXhG5amBAoGANXmC
+    8ypHYAaKoNdK+DWnMGCQtjijR4y1bceHTkI31WmXKelHzVp7wpcP+lz1y6/Ufm0O
+    XnyAo/f1XuRkFXmWY+TNKmrmK6O2pSIUmruLfzeWoIFleNXM/uMU6DYVinJjYKIj
+    Mj416swv7w+RFJ9epp6v9Ttxwm11IfsThzqarocCgYAPbtk6kqJwxq5I49NoC3Nm
+    WozUs31UywHJLS4JeudityA7ZTD8kULyhCig+Mrupiu3qLAmFtJzYFFIoP4msIOC
+    xMQ2qHvUyX9BwpONDwZ6fjwQYa8/kt22MelVICKqDpyYlOipV/YRKMNXsaQJd6xB
+    pkaCFGUW4xoRwTR/So/RnQ==
+    -----END PRIVATE KEY-----
+    (base) mike.boni@Mikes-MacBook-Pro ~ % cat public_key.pem
+
+    -----BEGIN PUBLIC KEY-----
+    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtpr7xFp/2jIpFwPPvz6N
+    kePjx8AvcMWtdH6++bEfVm7qvDWP8mNe+CR0eK0ZslfBJyhH8qE837L0zvOfJTw+
+    A7lChEofjQyoizVHWOIrK0dOtK8cyZ/t9DsypGSB1oSGWN46hMOwvoJTFRZqYbXI
+    uFkKj2MIta192LMBNDCYRf2vhwmeXqw5hE/zxWSbU0rMeO823nJNjJ37WiqRf8Ev
+    Y2LaVBa3/70rk6OENJYm2rohcD4AnmExhARhmylZ2wGzO9aqpozsU9CLVk27Kxlh
+    ueBur08YP5p88aSXzDZVTqIL/btmHBtJREP8aPT/PFgVj3RNEyuVd+xjqt7cL1K7
+    hwIDAQAB
+    -----END PUBLIC KEY-----

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$;
+  };
+}