http-request-manager 15.0.19 → 15.0.26

package/src/lib/services/utils/path-query.service.spec.ts

@@ -0,0 +1,117 @@
+import { TestBed } from '@angular/core/testing';
+import { PathQueryService } from './path-query.service';
+
+describe('PathQueryService', () => {
+  let service: PathQueryService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [PathQueryService]
+    });
+    service = TestBed.inject(PathQueryService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should build API path with only server', () => {
+    const result = service.buildAPIPath('http://example.com');
+    expect(result).toBe('http://example.com');
+  });
+
+  it('should build API path with server and path params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource']);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should build API path with server, path params, and query params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', { query: 'value' }]);
+    expect(result).toBe('http://example.com/path/to/resource?query=value');
+  });
+
+  it('should build API path with server and query params', () => {
+    const result = service.buildAPIPath('http://example.com', [{ query: 'value' }]);
+    expect(result).toBe('http://example.com?query=value');
+  });
+
+  it('should handle empty query params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', {}]);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should remove empty query params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', { query: '' }]);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should clean URL path', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', '', 'to', 'resource']);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should handle null query params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', null]);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should handle undefined query params', () => {
+    const result = service.buildAPIPath('http://example.com', ['path', 'to', 'resource', undefined]);
+    expect(result).toBe('http://example.com/path/to/resource');
+  });
+
+  it('should build API path with server as string array and path params', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource']);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should build API path with server as string array, path params, and query params', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: 'value' }]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value');
+  });
+
+  it('should build API path with server as string array and query params', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], [{ query: 'value' }]);
+    expect(result).toBe('http://example.com/api/v1?query=value');
+  });
+
+  it('should handle empty query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', {}]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should remove empty query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: '' }]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should clean URL path with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', '', 'to', 'resource']);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should handle null query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', null]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should handle undefined query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', undefined]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource');
+  });
+
+  it('should handle multiple query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query1: 'value1', query2: 'value2' }]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource?query1=value1&query2=value2');
+  });
+
+  it('should handle array query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', 'to', 'resource', { query: ['value1', 'value2'] }]);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value1%2Cvalue2');
+  });
+
+  it('should handle mixed path and query params with server as string array', () => {
+    const result = service.buildAPIPath(['http://example.com', 'api', 'v1'], ['path', { query: 'value' }, 'to', 'resource']);
+    expect(result).toBe('http://example.com/api/v1/path/to/resource?query=value');
+  });
+});

package/src/lib/services/utils/path-query.service.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PathQueryService {
+
+  buildAPIPath(server: string|string[], params?: any[]|any) {
+
+    server = (Array.isArray(server)) ? server.join('/') : server
+
+    const pathObjects = (params) ? params.filter((path:any) => (!this.isObject(path))) : []
+    const queryObjects = (params) ? params.filter((path:any) => (this.isObject(path))) : []
+
+    const query = this.removeEmptyParams(queryObjects.reduce((r: any, c: any) => {
+      Object.entries(c).forEach(([key, value]) => {
+        r[key] = Array.isArray(value) ? value.join(',') : value
+      })
+      return r
+    }, {}))
+
+    let path = this.buildRestPath(server, pathObjects)
+
+    return(Object.keys(query).length > 0) ? path + '?' + this.buildQueryPath(query) : path
+
+  }
+
+  private buildRestPath(server: string, params: any[]): string {
+    server = (server) ? server : ''
+    server = (server.charAt(0) === '/') ? server.substring(1) : server
+    return this.cleanUrlPath(server +'/'+ params.join('/'))
+  }
+
+  private buildQueryPath(params: any): string {
+
+    const searchParams = new URLSearchParams()
+
+    for (const key in params) {
+
+      if (Array.isArray(params[key])) {
+        params[key].forEach((value: any) => searchParams.append(key, value));
+      } else {
+        searchParams.append(key, params[key]);
+      }
+
+    }
+
+    return searchParams.toString()
+
+  }
+
+  private cleanUrlPath(str: string) {
+    return str.replace(/([^:]\/)\/+/g, "$1").replace(/\/$/,'')
+  }
+
+  private isObject(val: any): boolean {
+    return (val === null) ? false : ( (typeof val === 'function') || (typeof val === 'object') )
+  }
+
+  private removeEmptyParams = (obj: any): Record<string, any> =>
+    Object.fromEntries(
+      Object.entries(obj)
+        .map(([key, value]) =>
+          [key, value && typeof value === 'object' ? this.removeEmptyParams(value) : value]
+        )
+        .filter(([_, value]) => value !== undefined && value !== "")
+    )
+
+}

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

@@ -0,0 +1,164 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { UtilsService } from './utils.service';
+
+describe('UtilsService', () => {
+  let service: UtilsService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [UtilsService]
+    });
+    service = TestBed.inject(UtilsService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('Type Checks and JSON Conversions', () => {
+    it('should check string and object types', () => {
+      expect(service.isString('test')).toBeTrue();
+      expect(service.isString(123)).toBeFalse();
+      expect(service.isObject({})).toBeTrue();
+      expect(service.isObject('test')).toBeFalse();
+    });
+
+    it('should convert between JSON and string', () => {
+      const obj = { key: 'value' };
+      const jsonString = '{"key":"value"}';
+      expect(service.JSONToString(obj)).toBe(JSON.stringify(obj));
+      expect(service.JSONToString('test')).toBe('test');
+      expect(service.stringToJSON(jsonString)).toEqual(JSON.parse(jsonString));
+      expect(service.stringToJSON('test')).toBe('test');
+    });
+
+    it('should check if a string is valid JSON', () => {
+      expect(service.isJSON('{"key":"value"}')).toBeTrue();
+      expect(service.isJSON('not json')).toBeFalse();
+    });
+  });
+
+  describe('Object Access and Comparison', () => {
+    it('should return property value and compare objects', () => {
+      const obj = { key: 'value' };
+      expect(service.getValueByProp(obj, 'key')).toBe('value');
+      expect(service.getValueByProp(undefined, 'key')).toBeFalse();
+
+      const obj1 = { key: 'value', nested: { a: 1 } };
+      const obj2 = { key: 'value', nested: { a: 1 } };
+      const obj3 = { key: 'value', nested: { a: 2 } };
+      expect(service.objectsEqual(obj1, obj2)).toBeTrue();
+      expect(service.objectsEqual(obj1, obj3)).toBeFalse();
+    });
+  });
+
+  describe('HTTP and Getter', () => {
+    it('should obtain JSON from file', () => {
+      const dummyData = { key: 'value' };
+      service.getJSON('test.json').subscribe(data => {
+        expect(data).toEqual(dummyData);
+      });
+      const req = httpMock.expectOne('assets/data/test.json');
+      expect(req.request.method).toBe('GET');
+      req.flush(dummyData);
+    });
+
+    it('should return current time from today getter', () => {
+      const nowInSec = new Date().getMilliseconds() / 1000;
+      expect(service.today).toBeCloseTo(nowInSec, 0);
+    });
+  });
+
+  describe('Conversion Methods', () => {
+    it('should convert base32 to hex (simple case)', () => {
+      // For "A", expecting "0".
+      expect(service.base32ToHex('A')).toBe('0');
+    });
+
+    it('should convert binary to hex with 32-character padding', () => {
+      /* For the binary representation of "Hello":
+         H -> 01001000
+         e -> 01100101
+         l -> 01101100
+         l -> 01101100
+         o -> 01101111
+         -> Hex: "48656c6c6f"
+         Padded (22 zeros in front): "00000000000000000000000048656c6c6f"
+      */
+      const binary = '0100100001100101011011000110110001101111';
+      const expected = '000000000000000000000048656c6c6f';
+      expect(service.binaryToHex(binary)).toBe(expected);
+    });
+  });
+
+  describe('Expiry Calculations', () => {
+    // Helper to test expiry() returns a value close to now + (multiplier)
+    function expectExpiryClose(input: string, multiplier: number) {
+      const now = Math.floor(new Date().getTime() / 1000);
+      const expiry = service.expires(input);
+      expect(expiry).toBeGreaterThanOrEqual(now + multiplier - 1);
+      expect(expiry).toBeLessThanOrEqual(now + multiplier + 1);
+    }
+
+    it('should calculate expiry for various time units', () => {
+      expectExpiryClose("1y", 31556926);
+      expectExpiryClose("1m", 2629743);
+      expectExpiryClose("1w", 604800);
+      expectExpiryClose("1d", 86400);
+      expectExpiryClose("1hr", 3600);
+      expectExpiryClose("1mn", 60);
+      expectExpiryClose("1s", 1);
+    });
+
+    it('should return undefined for missing expiry string', () => {
+      expect(service.expires()).toBeUndefined();
+    });
+
+    it('should indicate if expired', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      expect(service.hasExpired(now - 10)).toBeTrue();
+      expect(service.hasExpired(now + 10)).toBeFalse();
+      expect(service.hasExpired(0)).toBeFalse();
+    });
+
+    it('should check setting for expiry', () => {
+      const settingWithExpiry = { expires: 1234567890 };
+      const settingWithoutExpiry = { key: 'value' };
+      expect(service.hasExpiry(settingWithExpiry)).toBeTrue();
+      expect(service.hasExpiry(settingWithoutExpiry)).toBeFalse();
+    });
+
+    it('should return a formatted string for future expiry dates', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      const future = now + 10000;
+      const result = service.expiresIn(future);
+      expect(typeof result).toBe('string');
+      expect(result).toBeDefined();
+      expect(result!.length).toBeGreaterThan(0);
+      // Expect one of the time unit labels in the formatted result.
+      expect(result).toMatch(/(y|m|w|d|h|min|s)/);
+    });
+
+    it('should return "Expired" for past or current expiry dates', () => {
+      const now = Math.floor(new Date().getTime() / 1000);
+      expect(service.expiresIn(now - 1)).toBe("Expired");
+      expect(service.expiresIn(now)).toBe("Expired");
+    });
+  });
+
+  describe('String Conversion', () => {
+    it('should convert string to lowercase with underscores', () => {
+      const input = 'Hello, World!';
+      // Expected conversion: remove punctuation, convert to lowercase, replace spaces with underscores.
+      expect(service.lc(input)).toBe('hello_world');
+    });
+  });
+});

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

@@ -0,0 +1,192 @@
+
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UtilsService {
+
+  http = inject(HttpClient)
+
+  constructor() { }
+
+  isString(x: string | number) {
+    return Object.prototype.toString.call(x) === '[object String]'
+  }
+
+  isObject(obj: any) {
+    return Object.prototype.toString.call(obj) === '[object Object]'
+  }
+
+  JSONToString(value: any) {
+    return (this.isObject(value)) ? JSON.stringify(value) : value
+  }
+
+  stringToJSON(value: string) {
+    return (this.isJSON(value)) ? JSON.parse(value) : value
+  }
+
+  isJSON(str: any) {
+    try {
+      JSON.parse(str)
+    } catch (e) {
+      return false
+    }
+    return true
+  }
+
+  getValueByProp(obj: any, prop: string) {
+    if(typeof obj === 'undefined') return false
+    return obj[prop]
+  }
+
+  objectsEqual(x: any, y: any): boolean {
+
+    const ok = Object.keys, tx = typeof x, ty = typeof y
+
+    return x && y && tx === 'object' && tx === ty ? (
+      ok(x).length === ok(y).length &&
+        ok(x).every((key: any) => this.objectsEqual(x[key], y[key]))
+    ) : (x === y)
+
+  }
+
+  getJSON(file: string) {
+    return this.http.get(`assets/data/${file}`)
+  }
+
+  get today() {
+    return new Date().getMilliseconds() / 1000
+  }
+
+  base32ToHex(base32: string): string {
+
+    const base32chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+
+    const charToValue = (char: string) => base32chars.indexOf(char.toUpperCase())
+
+    let bits = ''
+    let hex = ''
+
+    for (let i = 0; i < base32.length; i++) {
+      const val = charToValue(base32.charAt(i))
+      bits += val.toString(2).padStart(5, '0')
+    }
+
+    for (let i = 0; i + 4 <= bits.length; i += 4) {
+      const chunk = bits.substr(i, 4)
+      hex += parseInt(chunk, 2).toString(16)
+    }
+
+    return hex.toUpperCase()
+  }
+
+  binaryToHex(binary: string): string {
+    let hex = '';
+    for (let i = 0; i < binary.length; i += 8) {
+      const byte = binary.substr(i, 8);
+      const decimal = parseInt(byte, 2);
+      hex += decimal.toString(16).padStart(2, '0');
+    }
+    return hex.padStart(32, '0').substr(0, 32);
+  }
+
+  // y = years, m = months, w = weeks, d = days, hr = hours, mn = minutes else seconds
+  // returns epoch time corresponding to the expiry type
+  expires(str?: string) {
+
+    if(!str) return
+
+    const match = str.match(/[^0-9]+$/)
+
+    const type = (match) ? str.slice(-match[0].length) : 0
+
+    const now = Math.floor(new Date().getTime() / 1000)
+
+    let value = 0;
+
+    switch (type) {
+      case
+      'y':
+        const years = parseInt(str.slice(0, -1))
+        value = now + (years * 31556926)
+        break;
+      case
+      'm':
+        const months = parseInt(str.slice(0, -1))
+        value = now + (months * 2629743)
+        break;
+      case
+      'w':
+        const weeks = parseInt(str.slice(0, -1))
+        value = now + (weeks * 604800)
+        break;
+      case
+      'd':
+        const days = parseInt(str.slice(0, -1))
+        value = now + (days * 86400)
+        break;
+      case
+      'hr':
+        const hrs = parseInt(str.slice(0, -2))
+        value = now + (hrs * 3600)
+        break;
+      case
+      'mn':
+        const min = parseInt(str.slice(0, -2))
+        value = now + (min * 60)
+        break;
+      default: //seconds
+        const sec = parseInt(str.slice(0, -1))
+        value = now + (sec)
+        break;
+    }
+    return value;
+  }
+
+  hasExpired(expiryDate: number): boolean {
+    if (!expiryDate || expiryDate === 0) return false
+    const currentTime = Math.floor(new Date().getTime() / 1000)
+    return expiryDate < currentTime
+  }
+
+  hasExpiry(setting: any) {
+    return (setting?.expires) ? true : false
+  }
+
+  expiresIn(expiryDate: number) {
+
+    if (!expiryDate) return;
+
+    const now = Math.floor(new Date().getTime() / 1000);
+    let diff = expiryDate - now;
+
+    if (diff <= 0) return "Expired";
+
+    const units = [
+        { label: 'y', seconds: 31536000 },
+        { label: 'm', seconds: 2592000 },
+        { label: 'w', seconds: 604800 },
+        { label: 'd', seconds: 86400 },
+        { label: 'h', seconds: 3600 },
+        { label: 'min', seconds: 60 },
+        { label: '', seconds: 1 },
+    ];
+
+    let result = [];
+
+    for (const unit of units) {
+        if (diff >= unit.seconds) {
+            const value = Math.floor(diff / unit.seconds);
+            diff %= unit.seconds;
+            result.push(`${value}${unit.label}${value > 1 ? 's' : ''}`);
+        }
+    }
+
+    return result.join(', ');
+  }
+
+  lc = (str: string) => str.toLowerCase().replace(/[^\w\s]/g, '').replace(/\s+/g, '_')
+
+}

package/src/public-api.ts

@@ -0,0 +1,14 @@
+/*
+ * Public API Surface of http-request-manager
+ */
+
+export * from './lib/index';
+export * from './lib/http-request-manager.module';
+
+export * from './lib/http-request-services-demo/http-request-services-demo.component';
+
+export * from './lib/http-request-services-demo/database-data-demo/database-data-demo.component';
+export * from './lib/http-request-services-demo/local-storage-demo/local-storage-demo.component';
+export * from './lib/http-request-services-demo/request-manager-demo/request-manager-demo.component';
+export * from './lib/http-request-services-demo/request-manager-state-demo/request-manager-state-demo.component';
+

package/tsconfig.lib.json

@@ -0,0 +1,32 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/http-request-manager",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": [],
+    "baseUrl": "./",
+    "paths": {
+      "@angular/*": ["node_modules/@angular/*"],
+      "http-request-manager": ["node_modules/http-request-manager"],
+    },
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "ES2022"
+    ]
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+    "strictInjectionParameters": true,
+    "strictTemplates": true
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/esm2022/http-request-manager.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC1yZXF1ZXN0LW1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==