http-request-manager 15.0.26 → 18.0.2

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

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

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

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

@@ -1,18 +0,0 @@
-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/src/lib/interceptors/models/error-settings.model.ts

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

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

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

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

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

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

@@ -1,27 +0,0 @@
-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/src/lib/models/data-type.enum.ts

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

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

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

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

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

@@ -1,193 +0,0 @@
-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;
-  }
-
-}