http-request-manager 15.0.24 → 15.0.26

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

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+
+import { DataType, DatabaseStorage } from '../../../models';
+import { HTTPManagerStateService, ApiRequest, RequestOptions } from '../../../services';
+
+import { ClientInfo } from '../../request-manager-demo/models/sample-client-info';
+import { ClientInfoMapper } from '../../request-manager-demo/models/sample-mapper-client-info';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StateManagerDemoService extends HTTPManagerStateService<any> {
+
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: "",
+        path: [],
+        headers: {},
+        adapter: ClientInfo.adapt,
+        mapper: ClientInfoMapper.adapt,
+        stream: false,
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt()
+    )
+  }
+
+  setAPIOptions(apiOptions: ApiRequest, dataType: DataType, database?: DatabaseStorage) {
+    this.setApiRequestOptions(apiOptions, dataType, database)
+  }
+
+  getClients() {
+
+    // const headers = {
+    //   auth: "sample-auth-token"
+    // }
+    // const sampleOptions = RequestOptions.adapt({ path: ["id", 12], headers, sample: true })
+    this.fetchRecords()
+
+  }
+
+  createClient(data: any) {
+
+    // const headers = {
+    //   auth: "sample-auth-token"
+    // }
+
+    // const sampleOptions = RequestOptions.adapt({ path: ["id", 12], headers, sample: true })
+    this.createRecord(data)
+
+  }
+
+  updateClient(data: ClientInfo) {
+
+    // const headers = {
+    //   auth: "sample-auth-token"
+    // }
+    data.id = 1031
+    const sampleOptions = RequestOptions.adapt({ path: [data.id] })
+    this.updateRecord(data, sampleOptions)
+
+  }
+
+  deleteClient(data: ClientInfo) {
+
+    // const headers = {
+    //   auth: "sample-auth-token"
+    // }
+
+    data.id = 1031
+    const sampleOptions = RequestOptions.adapt({ path: [data.id] })
+    this.deleteRecord(sampleOptions)
+
+  }
+
+  streamRequest() {
+
+    const headers = {
+      auth: "sample-auth-token"
+    }
+
+    // const sampleOptions = RequestOptions.adapt({ path: [1], headers })
+    this.fetchStream()
+
+  }
+
+}

package/src/lib/index.ts

@@ -0,0 +1,3 @@
+export * from "./services/index"
+export * from "./interceptors/index"
+export * from "./models/index"

package/src/lib/interceptors/credentials.interceptor.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpEvent, HttpInterceptor, HttpHandler, HttpRequest
+} from '@angular/common/http';
+
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class WithCredentialsInterceptor implements HttpInterceptor {
+
+  intercept(req: HttpRequest<any>, next: HttpHandler):
+    Observable<HttpEvent<any>> {
+
+      req = req.clone({ withCredentials: true })
+
+      return next.handle(req);
+  }
+}

package/{lib/interceptors/index.d.ts → src/lib/interceptors/index.ts}

@@ -1,4 +1,6 @@
+
 export * from "./models/error-settings.model";
+
 export * from "./credentials.interceptor";
 export * from "./request-header.interceptor";
 export * from "./request-error.interceptor";

package/src/lib/interceptors/models/error-settings.model.ts

@@ -0,0 +1,22 @@
+export interface ErrorDisplaySettingsInterface {
+  displayTime: number
+  position: string
+}
+
+export class ErrorDisplaySettings implements ErrorDisplaySettingsInterface {
+
+  constructor(
+    public displayTime = 3 * 1000,
+    public position = 'top'
+  ) {}
+
+  static adapt(item?: any): ErrorDisplaySettings {
+
+    return new ErrorDisplaySettings(
+      (item?.displayTime) ? item.displayTime * 1000 : 3 * 1000,
+      item?.position,
+    )
+
+  }
+
+}

package/src/lib/interceptors/proxy-debugger.interceptor.ts

@@ -0,0 +1,46 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+export const PROXY_CONFIG = new InjectionToken<Record<string, any>>('PROXY_CONFIG');
+
+@Injectable()
+export class ProxyDebuggerInterceptor implements HttpInterceptor {
+
+  constructor(@Optional() @Inject(PROXY_CONFIG) private proxyConfig: Record<string, any>) {}
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+
+    if (!this.proxyConfig) {
+      return next.handle(req);
+    }
+
+    const headers = req.headers.keys().reduce((acc, key) => {
+      acc[key] = req.headers.get(key) || '';
+      return acc;
+    }, {} as Record<string, string>);
+
+    for (const proxyPath in this.proxyConfig) {
+      if (this.proxyConfig.hasOwnProperty(proxyPath)) {
+        const proxyDetails = this.proxyConfig[proxyPath];
+        const regex = new RegExp('^' + proxyPath.replace('/', '').replace('*', '(.*)'));
+
+        if (regex.test(req.url)) {
+          const target = proxyDetails.target;
+          const endpoint = req.url.replace(regex, '$1');
+          const actualPath = target + '/' + endpoint;
+
+          console.log('Request Proxied:', {
+            requestUrl: req.url,
+            requestPayload: req.body,
+            headers: headers,
+            proxyPath: proxyPath,
+            actualPath: actualPath,
+          });
+        }
+      }
+    }
+
+    return next.handle(req);
+  }
+}

package/src/lib/interceptors/request-error.interceptor.ts

@@ -0,0 +1,65 @@
+import { inject, Injectable } from '@angular/core'
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpErrorResponse } from '@angular/common/http'
+import { Observable, catchError, throwError } from 'rxjs'
+
+import { ToastMessageDisplayService, ToastDisplay, ToastColors } from 'toast-message-display'
+
+@Injectable()
+export class RequestErrorInterceptor implements HttpInterceptor {
+
+  toastMessage = inject(ToastMessageDisplayService)
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+
+    return next.handle(req).pipe(
+
+      catchError((error: HttpErrorResponse) => {
+
+        const displayError = ToastDisplay.adapt({
+          message: 'This is a toast message. This is an Error!!',
+          action: 'OK',
+          color: ToastColors.SUCCESS,
+          icon: 'info',
+          duration: 5 * 1000, //5 seconds
+        })
+
+        if (error.status >= 400 && error.status < 500) {
+
+          displayError.color = ToastColors.WARN
+          displayError.message = error.error || `${error.status}: ${error.statusText}`
+
+          console.error('Client Error:', {
+            status: error.status,
+            message: error.message,
+            error: error.error,
+            text: error.statusText,
+          })
+
+          this.toastMessage.toastMessage(displayError)
+
+        } else if (error.status >= 500) {
+
+          displayError.color = ToastColors.ERROR
+          displayError.message = error.error || `${error.status}: ${error.statusText}`
+
+          console.error('Server Error:', {
+            status: error.status,
+            message: error.message,
+            error: error.error,
+            text: error.statusText,
+          })
+
+          this.toastMessage.toastMessage(displayError)
+
+        }
+
+        return throwError(() => error)
+
+      })
+
+    )
+  }
+
+}
+
+

package/src/lib/interceptors/request-header.interceptor.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+} from '@angular/common/http';
+import { Observable, Subscription } from 'rxjs';
+import { LangChangeEvent, TranslateService } from '@ngx-translate/core';
+
+@Injectable()
+export class RequestHeadersInterceptor implements HttpInterceptor {
+
+  subscriptions = new Subscription()
+  language = 'en-CA'
+
+  get currentDate() {
+
+    const date = new Date()
+
+    const year = date.getFullYear()
+    const month = String(date.getMonth() + 1).padStart(2, '0')
+    const day = String(date.getDate()).padStart(2, '0')
+
+    return `${year}-${month}-${day}`
+
+  }
+
+  constructor(
+    private translate: TranslateService
+  ) {
+    this.subscriptions.add(
+      this.translate.onLangChange
+      .subscribe((params: LangChangeEvent) => {
+          this.language = `${params.lang}-CA`
+      })
+    )
+  }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+
+    request = request.clone({
+      setHeaders: {
+        'Content-Type': 'application/json',
+        'Accept-Language': this.language || 'en-CA',
+        'Current-Date': this.currentDate
+      }
+    })
+
+    return next.handle(request)
+
+  }
+
+  ngOnDestroy() {
+    this.subscriptions.unsubscribe()
+  }
+}
+

package/src/lib/models/config-http-options.model.ts

@@ -0,0 +1,42 @@
+import { RetryOptions } from "./retry-options.model"
+
+export interface ConfigHTTPOptionsInterface {
+  server: string
+  path?: any[]
+  headers?: any
+  polling?: number // seconds (undefined | 0 = none)
+  retry?: RetryOptions
+  stream?: boolean
+  displayError?: boolean
+}
+
+export class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
+
+  constructor(
+    public server = '',
+    public path?: any[],
+    public headers?: any,
+    public polling?: number,
+    public retry?: RetryOptions,
+    public stream?: boolean,
+    public displayError?: boolean,
+  ) {}
+
+  static adapt(item?: any): ConfigHTTPOptions {
+
+    const server = Array.isArray(item?.server) ? item.server.join('/') : item?.server || '';
+    const retryOptions = item?.retry ? RetryOptions.adapt(item.retry) : RetryOptions.adapt();
+
+    return new ConfigHTTPOptions(
+      server,
+      (item?.path) ? item.path : [],
+      (item?.headers) ? item.headers : {},
+      item?.polling ? Math.floor(item.polling) : 0,
+      retryOptions,
+      (item?.stream) ? item.stream : false,
+      (item?.displayError) ? item.displayError : false,
+    )
+
+  }
+
+}

package/src/lib/models/config-local-storage-options.model.ts

@@ -0,0 +1,27 @@
+import { SettingOptions } from "../services"
+
+export interface LocalStorageOptionsInterface {
+  storageName?: string
+  storageSettingsName?: string
+  options?: SettingOptions,
+}
+
+export class LocalStorageOptions implements LocalStorageOptionsInterface {
+
+  constructor(
+    public storageName?: string,
+    public storageSettingsName?: string,
+    public options?: SettingOptions,
+  ) {}
+
+  static adapt(item?: any): LocalStorageOptions {
+
+    return new LocalStorageOptions(
+      (item?.storageName) ? item.storageName : 'storage',
+      (item?.storageSettingsName) ? item.storageSettingsName : 'global-storage',
+      (item?.options) ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
+    )
+
+  }
+
+}

package/src/lib/models/config-options.model.ts

@@ -0,0 +1,27 @@
+import { ConfigHTTPOptions } from "./config-http-options.model";
+import { LocalStorageOptions } from "./config-local-storage-options.model";
+
+export interface ConfigOptionsInterface {
+  httpRequestOptions?: ConfigHTTPOptions
+  LocalStorageOptions?: LocalStorageOptions
+  // DatabaseOptions: any
+}
+
+export class ConfigOptions implements ConfigOptionsInterface {
+
+  constructor(
+    public httpRequestOptions?: ConfigHTTPOptions,
+    public LocalStorageOptions?: LocalStorageOptions,
+    // public DatabaseOptions?: any,
+  ) {}
+
+  static adapt(item?: any): ConfigOptions {
+    return new ConfigOptions(
+      (item?.httpRequestOptions) ? ConfigHTTPOptions.adapt(item.httpRequestOptions) : undefined,
+      (item?.LocalStorageOptions) ? LocalStorageOptions.adapt(item.LocalStorageOptions) : undefined,
+      // item?.DatabaseOptions,
+    )
+
+  }
+
+}

package/{lib/models/config-token.model.d.ts → src/lib/models/config-token.model.ts}

@@ -1,8 +1,9 @@
 import { InjectionToken } from "@angular/core";
 import { ConfigOptions } from "./config-options.model";
+
 /**
  * An injection token that provides the configuration settings for the application.
  * This token can be used to inject the `ConfigSettings` instance into components or services
  * that require access to the application configuration.
  */
-export declare const CONFIG_SETTINGS_TOKEN: InjectionToken<ConfigOptions>;
+export const CONFIG_SETTINGS_TOKEN = new InjectionToken<ConfigOptions>('http.config');

package/src/lib/models/data-type.enum.ts

@@ -0,0 +1,5 @@
+export enum DataType {
+  ANY = 0,
+  ARRAY,
+  OBJECT
+}

package/src/lib/models/database-storage.model.ts

@@ -0,0 +1,24 @@
+import { DataType } from "./data-type.enum"
+
+export interface DatabaseStorageInterface {
+  table: string
+  expiresIn: string
+}
+
+export class DatabaseStorage implements DatabaseStorageInterface {
+  
+  constructor(
+    public table = '',
+    public expiresIn: '',
+  ) {}
+
+  static adapt(item?: any): DatabaseStorage {
+
+    return new DatabaseStorage(
+      item?.table,
+      item?.expiresIn,
+    )
+
+  }
+
+}

package/src/lib/models/index.ts

@@ -0,0 +1,9 @@
+export * from './database-storage.model'
+export * from './retry-options.model'
+
+export * from './data-type.enum'
+
+export * from './config-http-options.model'
+export * from './config-local-storage-options.model'
+export * from './config-options.model'
+

package/src/lib/models/retry-options.model.ts

@@ -0,0 +1,22 @@
+export interface RetryOptionsInterface {
+  times?: number // total request to be made including initial request
+  delay?: number // seconds (<= 3 default 3 seconds)
+}
+
+export class RetryOptions implements RetryOptionsInterface {
+
+  constructor(
+    public times = 0,
+    public delay = 3,
+  ) {}
+
+  static adapt(item?: any): RetryOptions {
+
+    return new RetryOptions(
+      item?.times,
+      item?.delay
+    )
+
+  }
+
+}

package/src/lib/services/database-manager-services/database.manager.service.ts

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+import { DbService } from './db.storage.service';
+
+import { TableSchemaDef } from './models/table-schema';
+import { EMPTY, from, Observable } from 'rxjs';
+import { map, mergeMap, switchMap } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DatabaseManagerService extends DbService {
+
+  constructor() { 
+    super()
+    this.createNewDatabase()
+  }
+
+  getDatabaseTables() {
+    return from(this.DBOpened()).pipe(
+      map(() => this.db.tables.map(item => item.name))
+    )
+  }
+
+  hasDatabaseTable(table: string): Observable<boolean> {
+    return from(this.DBOpened()).pipe(
+      map(() => {
+        return this.tableExists(this.clean(table))
+      })
+    )
+  }
+
+  getDatabaseTable(table: string): Observable<any> {
+    return from(this.DBOpened()).pipe(
+      map((res) => {
+        this.hasDatabase().then((res) => {
+
+          const tables = this.db.tables
+          const found = tables.find(item => item.name === this.clean(table)) || null
+
+          if(!found) {
+            console.warn('No Such Table:', this.clean(table))
+            return
+          } else { 
+            return found
+          }
+          
+        })
+      })
+    )
+  }
+
+  getDatabaseTableSchema(table: string): Observable<string[]> {
+
+    return from(this.DBOpened()).pipe(
+      mergeMap((res) => this.getDatabaseTable(table)),
+      map((dbTable: any) => {
+        if(!dbTable) return []
+        const cols = dbTable.schema.indexes.map((col: any) => col.name)
+        const pri = dbTable.schema.primKey.name
+        return [pri, ...cols]
+      })
+    )
+
+  }
+
+  createDatabaseTable(tableDef: TableSchemaDef) {
+    this.createTable(tableDef.table, tableDef.schema)
+    return from(this.DBOpened())
+  }
+
+  updateDatabaseTableSchema(tableDef: TableSchemaDef) {
+
+  }
+
+  // CRUD
+  findTableRecords(table: string, column: string, value: any) {
+  
+  }
+
+  findTableRecord(table: string, column: string, value: any) {
+    
+  }
+
+  getTableRecords(table: string) {
+    
+  }
+
+  getTableRecord(table: string, id: number) {
+    
+  }
+
+  createTableRecord(table: string, record: any) {
+    return this.createTableRecords(table, [record])
+    .pipe(
+      map((item: any) => item ? item[0] : null))
+  }
+
+  createTableRecords(table: string, records: any[]) {
+
+    return this.getDatabaseTable(table).pipe(
+
+      switchMap((tableData: any) => {
+        
+        if(!tableData) return EMPTY
+
+        return this.getDatabaseTableSchema(table).pipe(
+
+          map((schema: string[]) => {
+
+            const insertRecords = records.map((record: any) => {
+
+              const objectFromSchema: { [key: string]: any } = {}
+
+              schema.forEach((field: string) => {
+                const data = (record as any)[field] ?? null
+                objectFromSchema[field] = data
+              })
+
+              return objectFromSchema
+
+            })
+
+            tableData.bulkPut(insertRecords)
+            return insertRecords
+
+          })
+
+        )
+
+      })
+
+    )
+
+  }
+
+  updateTableRecord(table: string, record: any) {
+    return this.updateTableRecords(table, [record])
+    .pipe(
+      map(item => item.length > 0 ? item[0] : null)
+    )
+  }
+
+  updateTableRecords(table: string, records: any[]) {
+    
+    return this.getDatabaseTable(table).pipe(
+
+      switchMap((tableData: any) => {
+
+        return this.getDatabaseTableSchema(table).pipe(
+
+          map((schema: string[]) => {
+
+            const insertRecords = records.map((record: any) => {
+
+              const objectFromSchema: { [key: string]: any } = {}
+
+              schema.forEach((field: string) => {
+                const data = (record as any)[field] ?? null
+                objectFromSchema[field] = data
+              })
+
+              return objectFromSchema
+
+            })
+
+            tableData.bulkPut(insertRecords).then(() => console.log('Updated DB'))
+            return insertRecords
+
+          })
+
+        )
+
+      })
+
+    )
+
+  }
+
+  deleteTableRecord<T>(table: string, id: number) {
+    
+  }
+
+  private clean(str: string): string {
+    const cleanStr = str
+      .replace(/[^a-zA-Z0-9\s]/g, '_') // Replace non-alphanumeric characters except spaces with underscores
+      .replace(/\s+/g, '_')            // Replace spaces with underscores
+      .toLowerCase()                   // Convert to lowercase
+      .trim();                         // Trim leading or trailing spaces
+  
+    return cleanStr;
+  }
+
+}