http-request-manager 15.0.24 → 15.0.26

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

@@ -0,0 +1,402 @@
+import { inject, Inject, Injectable, InjectionToken } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+
+import { BehaviorSubject, of } from 'rxjs';
+import { tap, switchMap, concatMap, scan, delay } from 'rxjs/operators';
+import { DatabaseStorage } from '../../models/database-storage.model';
+import { HTTPManagerService, DataType } from '../request-manager-services';
+import { ApiRequest, RequestOptions } from './models';
+
+
+const API_OPTS = new InjectionToken<ApiRequest>('API_OPTS');
+
+export interface APIStateManagerData<T> {
+  data: T[]
+  dataObject: T | null
+}
+
+const defaultState: APIStateManagerData<any> = {
+  data: [],
+  dataObject: null,
+};
+
+@Injectable()
+export class HTTPManagerStateService<T extends { id: number }> extends ComponentStore<APIStateManagerData<T>> {
+
+  httpManagerService = inject(HTTPManagerService)
+
+  error$ = this.httpManagerService.error$
+  isPending$ = this.httpManagerService.isPending$.pipe(delay(1))
+
+  // PAGINATION
+  private page = new BehaviorSubject<number>(0)
+  page$ = this.page.asObservable()
+
+  private totalPages = new BehaviorSubject<number>(0)
+  totalPages$ = this.totalPages.asObservable()
+
+  private percentage = new BehaviorSubject<number>(0)
+  percentage$ = this.percentage.asObservable()
+  // ----------
+
+  private hasDatabase = false
+
+  streamedResponse = []
+
+  constructor(
+    @Inject(API_OPTS) private apiOptions = ApiRequest.adapt(),
+    @Inject("dataType") private dataType: DataType | undefined,
+    @Inject("database") private database?: DatabaseStorage | undefined
+  ) {
+    super(defaultState);
+    this.setApiRequestOptions(apiOptions, dataType, database)
+  }
+
+  setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage) {
+
+    this.apiOptions = ApiRequest.adapt(apiOptions)
+    this.dataType = (dataType) ? dataType : DataType.ARRAY
+
+    this.hasDatabase = this.database?.table === "" ? false : true
+    this.database = (this.hasDatabase) ? DatabaseStorage.adapt(database) : undefined
+
+  }
+
+  get ApiRequestOptions() {
+    return this.apiOptions
+  }
+
+  initStorage() {
+    // if(this.otherOptions.database) {
+      // console.log('Has Database Option:', this.otherOptions.database.table)
+      // const schema = (this.otherOptions.adapters?.incoming) ? Object.keys(this.otherOptions.adapters.incoming({})).join() : '++id'
+      // this.apiService.initDB(this.otherOptions.database.expiresIn, this.otherOptions.database.table, schema)
+    // }
+  }
+
+  initializeState(data: any) {
+    this.setData$(data)
+  }
+
+  // --------------------------------------------------------------------------------------------------
+  // SELECTORS
+
+  readonly data$ = this.select(({ data, dataObject }) => {
+    const isArray =( this.dataType === DataType.ARRAY) ? true : false
+    return (isArray) ? data : dataObject
+  })
+
+  readonly selectRecord$ = (id: number) => this.select(
+    this.data$,
+    (data) => {
+      if (this.dataType === DataType.ARRAY && Array.isArray(data)) {
+        return data.find(item => item.id === id) as T | null
+      } else {
+        return (data as T).id === id ? data : null
+      }
+    }
+  );
+
+  // --------------------------------------------------------------------------------------------------
+
+  // UPDATERS
+
+  private readonly setData$ = this.updater((state: APIStateManagerData<T>, data: T | T[] | any) => {
+
+    if (!data) return state;
+
+    if (this.dataType === DataType.ARRAY) {
+
+      const dataArray = Array.isArray(data) ? data : [data]
+
+      const stateDataSample = (state.data.length > 0) ? Object.keys(state.data[0]) : []
+      const newDataSample = (dataArray.length > 0) ? Object.keys(dataArray[0]) : []
+
+      const isSame = (state.data.length === 0) ? false : stateDataSample.every((value, index) => value === newDataSample[index])
+      const updatedData = (!isSame && dataArray.length !== 0) ? this.updateArrayState([], dataArray) : this.updateArrayState(state.data, dataArray)
+
+      return { ...state, data: updatedData, dataObject: null } as APIStateManagerData<T>;
+
+    } else {
+      const dataObject = this.isEmpty(data) ? null : data;
+      return { ...state, data: [], dataObject: dataObject } as APIStateManagerData<T>;
+    }
+
+  });
+
+  private updateArrayState(currentData: any[], newData: any[]): any[] {
+
+    const filterCurrentData = () => {
+      const ids = this.streamedResponse.map((obj: any) => obj.id)
+      return currentData.filter(obj => (obj.id) ? ids.includes(obj.id) : obj)
+    }
+
+    const filteredCurrentData = (this.httpManagerService.isPending.value) ? currentData : filterCurrentData()
+
+    const updatedData = filteredCurrentData.map(item => {
+        const newItem = newData.find(newItem => {
+          const hasId = (newItem?.id && item?.id) ? true : false
+          return (hasId) ? newItem.id === item.id : JSON.stringify(newItem) === JSON.stringify(item)
+        })
+        return (newItem) ? { ...item, ...newItem } : item
+    })
+
+    const addedData = newData.filter(newItem => {
+      return !filteredCurrentData.some(item => {
+          const hasId = (newItem?.id && item?.id) ? true : false
+          return (hasId) ? item.id === newItem.id : JSON.stringify(newItem) === JSON.stringify(item)
+      })
+    })
+
+    return [...updatedData, ...addedData]
+
+}
+
+  private readonly addData$ = this.updater((state: APIStateManagerData<T>, data: T) => {
+
+    if (this.dataType === DataType.ARRAY) {
+      const newState = [...state.data, data];
+      return { ...state, ...{ data: newState } }
+    } else {
+      return { ...state, ...{ dataObject: data } }
+    }
+
+  })
+
+  private readonly deleteData$ = this.updater((state: APIStateManagerData<T>, data: T & { id: number }) => {
+    if (this.dataType === DataType.ARRAY) {
+    const newState = state.data.filter(item => item.id !== data.id)
+    return { ...state, ...{ data: newState } }
+    } else {
+      return { ...state, ...{ dataObject: null } }
+    }
+  })
+
+  private readonly updateData$ = this.updater((state: APIStateManagerData<T>, data: T) => {
+
+    if (this.dataType === DataType.ARRAY) {
+
+      const objIndex = state.data.findIndex(item => item.id === data.id)
+
+      if (objIndex > -1) {
+        const newState = [...state.data]
+        newState[objIndex] = data
+        return { ...state, ...{ data: newState } }
+      }
+
+      return state
+
+    } else {
+      return { ...state, ...{ dataObject: data } }
+    }
+
+  })
+
+  // --------------------------------------------------------------------------------------------------
+  // EFFECTS
+
+  readonly clearRecords = this.effect(data =>
+    data.pipe(
+      tap(() => {
+        if (this.dataType === DataType.ARRAY) {
+          this.setData$([])
+        } else {
+          this.setData$({})
+        }
+      })
+  ))
+
+  readonly refreshData = this.effect(data =>
+    data.pipe(
+      tap(() => {
+        // this.apiService.flushDatabase(this.otherOptions.database?.table)
+        this.fetchRecords()
+      })
+  ))
+
+  // --------------------------------------------------------------------------------------------------
+  // CRUD OPERATIONS
+
+  // FETCH RECORDS
+  readonly fetchRecords = (options?: RequestOptions) =>
+    this.effect<any>(() =>
+    of(RequestOptions.adapt(options)).pipe(
+      switchMap(() => {
+
+        this.streamedResponse = []
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        return this.httpManagerService.getRequest(requestOptions, options?.path)
+        .pipe(
+          tap((data: any) => {
+            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
+            this.setData$(data)
+          })
+        )
+
+      })
+    )
+  )
+
+  // CREATE RECORD
+  readonly createRecord = (data: any|null, options?: RequestOptions) =>
+    this.effect<any>(() =>
+      of(data).pipe(
+        switchMap((data: any) => {
+
+        this.streamedResponse = []
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        return this.httpManagerService.postRequest(data, requestOptions, options?.path)
+        .pipe(
+          tap((data: any) => {
+            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
+            this.addData$(data)
+          }),
+        )
+
+      })
+    )
+  )
+
+  // UPDATE RECORD
+  readonly updateRecord = (data: any|null, options?: RequestOptions) =>
+    this.effect<any>(() =>
+    of(data).pipe(
+      concatMap((data: any) => {
+
+        this.streamedResponse = []
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        return this.httpManagerService.putRequest(data, requestOptions, options?.path)
+        .pipe(
+          tap((data: any) => {
+            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
+            this.updateData$(data)
+          }),
+        )
+
+      })
+    )
+  )
+
+  // DELETE RECORD
+  readonly deleteRecord = (options?: RequestOptions) =>
+    this.effect<any>(() =>
+    of(options).pipe(
+      concatMap((data: any) => {
+
+        this.streamedResponse = []
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        return this.httpManagerService.deleteRequest(requestOptions, options?.path)
+        .pipe(
+          tap((data: any) => {
+            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
+            this.deleteData$(data)
+          }),
+        )
+
+      })
+    )
+  )
+
+  // --------------------------------------------------------------------------------------------------
+  // FETCH STREAM
+
+  readonly createStream = (data: any|null, options?: RequestOptions) =>
+    this.effect<any>(() =>
+    of(data).pipe(
+      tap(() => this.httpManagerService.isPending.next(true)),
+      switchMap((data: any) => {
+
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        return this.httpManagerService.postRequest(data, requestOptions, options?.path)
+        .pipe(
+          tap((res: any) => {
+            if(res.length > 0) this.setData$(res)
+            this.streamedResponse = res
+          }),
+          scan((acc, res: any) => {
+
+            const previous = acc.current
+            const current = res
+            return { previous, current };
+
+          }, { previous: null, current: null }),
+          tap(({ previous, current }) => {
+
+            if(previous && JSON.stringify(previous) === JSON.stringify(current)) {
+              this.httpManagerService.isPending.next(false)
+              this.setData$([])
+            } else {
+              this.httpManagerService.isPending.next(true)
+            }
+
+          })
+        )
+
+      })
+    )
+
+  )
+
+  readonly fetchStream = (options?: RequestOptions) =>
+    this.effect<any>(() =>
+    of(options).pipe(
+      tap(() => this.httpManagerService.isPending.next(true)),
+      switchMap((options: any) => {
+
+        const requestOptions = this.updateRequestOptions(options?.headers)
+        requestOptions.stream = true
+
+        return this.httpManagerService.getRequest(requestOptions, options?.path)
+        .pipe(
+          tap((res: any) => {
+
+            if(res.length > 0) this.setData$(res)
+            this.streamedResponse = res
+          }),
+          scan((acc, res: any) => {
+
+            const previous = acc.current
+            const current = res
+            return { previous, current }
+
+          }, { previous: null, current: null }),
+          tap(({ previous, current }) => {
+
+            if(previous && JSON.stringify(previous) === JSON.stringify(current)) {
+              this.httpManagerService.isPending.next(false)
+              this.setData$([])
+            } else {
+              this.httpManagerService.isPending.next(true)
+            }
+
+          })
+        )
+
+      }),
+    )
+  )
+
+  // --------------------------------------------------------------------------------------------------
+  // MISC
+
+  private isEmpty(obj: any) {
+    return Object.keys(obj).length === 0
+  }
+
+  private updateRequestOptions(headers?: any): ApiRequest {
+
+    const options = ApiRequest.adapt({ ...this.apiOptions })
+
+    options.headers = (headers)
+          ? { ...options.headers, ...headers }
+          : { ...options.headers }
+
+    return options
+  }
+
+}

package/{lib/services/request-manager-state-service/index.d.ts → src/lib/services/request-manager-state-service/index.ts}

@@ -1,2 +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,50 @@
+import { RetryOptions } from "../../request-manager-services"
+
+export interface ApiRequestInterface {
+  server: string
+  path?: any[]
+  headers?: any
+  adapter?: any
+  mapper?: any
+  polling?: number // seconds (undefined | 0 = none)
+  retry?: RetryOptions
+  stream?: boolean
+  displayError?: boolean
+  saveAs?: string
+}
+
+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 displayError?: boolean,
+    public saveAs?: string,
+  ) {}
+
+  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?.displayError) ? item.displayError : false,
+      item?.saveAs,
+    )
+
+  }
+
+}

package/{lib/services/request-manager-state-service/models/index.d.ts → src/lib/services/request-manager-state-service/models/index.ts}

@@ -1,2 +1,3 @@
 export * from "./api-request.model";
 export * from "./request-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/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-----