http-request-manager 18.3.2 → 18.4.0

package/README.md

@@ -1,333 +1,556 @@
 # Request Manager Service Documentation
 
-## Summary of the Lib
-The HTTPManagerService is a collection of 4 services for HTTP and Local Storage management.
-
-## Installation
-
-`npm install http-request-manager`
+## Summary
+The `http-request-manager` library provides a comprehensive set of services for handling HTTP requests, state management, local storage, and WebSocket communications in Angular applications.
+
+## Initialization
+
+### 1. Module Initialization (`forRoot`)
+To use the library, import `HttpRequestManagerModule` in your `AppModule` and configure it using the `forRoot` method.
+
+#### Configuration Options (`ConfigOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `httpRequestOptions` | `ConfigHTTPOptions` | Global configuration for HTTP requests. | `undefined` |
+| `LocalStorageOptions` | `LocalStorageOptions` | Global configuration for Local Storage management. | `undefined` |
+
+#### HTTP Options (`ConfigHTTPOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `server` | `string` | The base URL for API requests. | `''` |
+| `path` | `any[]` | Default path segments to append to the server URL. | `[]` |
+| `headers` | `any` | Default headers to include in every request. | `{}` |
+| `polling` | `number` | Default polling interval in seconds (0 = disabled). | `0` |
+| `retry` | `RetryOptions` | Default retry configuration. | `{ times: 0, delay: 3 }` |
+| `stream` | `boolean` | Whether to enable streaming by default. | `false` |
+| `displayError` | `boolean` | Whether to display toast notifications for errors by default. | `false` |
+
+#### Retry Options (`RetryOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `times` | `number` | The number of retry attempts. | `0` |
+| `delay` | `number` | The delay between retries in seconds. | `3` |
+
+#### Local Storage Options (`LocalStorageOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `storageName` | `string` | The key used to store data in localStorage/sessionStorage. | `'storage'` |
+| `storageSettingsName` | `string` | The key used to store settings metadata. | `'global-storage'` |
+| `options` | `SettingOptions` | Default settings for stored items. | `{ storage: StorageType.GLOBAL, expires: 0, expiresIn: '', encrypted: false }` |
+
+#### Setting Options (`SettingOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `storage` | `StorageType` | The type of storage to use (`StorageType.GLOBAL` or `StorageType.SESSION`). | `StorageType.GLOBAL` |
+| `expires` | `number` | Expiration timestamp (epoch). Usually calculated from `expiresIn`. | `0` |
+| `expiresIn` | `string` | Duration string (e.g., '1d', '2h') for expiration. | `''` |
+| `encrypted` | `boolean` | Whether to encrypt the stored data. | `false` |
+
+#### Example
+
+```typescript
+import { HttpRequestManagerModule } from 'http-request-manager';
+
+@NgModule({
+  imports: [
+    HttpRequestManagerModule.forRoot({
+      httpRequestOptions: {
+        server: 'https://api.example.com',
+        headers: { 'Authorization': 'Bearer token' },
+        retry: { times: 3, delay: 2 },
+        displayError: true
+      },
+      LocalStorageOptions: {
+        storageName: 'my-app-data',
+        storageSettingsName: 'my-app-settings',
+        options: {
+          encrypted: true,
+          expiresIn: '7d'
+        }
+      }
+    })
+  ],
+  // ...
+})
+export class AppModule { }
+```
 
-## Services
+### 2. AppService Initialization
+The `AppService` (used by `LocalStorageManagerService` for encryption) requires a unique `APP_ID` to be provided in your `AppModule`.
+
+```typescript
+import { APP_ID } from '@angular/core';
+
+@NgModule({
+  providers: [
+    {
+      provide: APP_ID,
+      useValue: "your-unique-guid-here", // e.g., "056991ac-3537-43ab-b5b9-83edf6554eff"
+    },
+    // ...
+  ],
+  // ...
+})
+export class AppModule { }
+```
 
-### HTTP Manager Service: 
+## Services Documentation
+
+### 1. Request Manager Service (`HTTPManagerService`)
+**Path:** `request-manager-services/http-manager.service.ts`
+
+A robust HTTP client service using RxJS `BehaviorSubject` for state management.
+
+**What it does:**
+This service acts as a wrapper around Angular's `HttpClient`, providing a centralized way to manage HTTP requests. It handles the entire lifecycle of a request, including loading states, error handling, and data updates, exposing them as Observables.
+
+**Features:**
+- **State Management:** Exposes `data$`, `isPending$`, `error$`, and `countdown$` observables.
+- **Polling:** Supports automatic polling of endpoints with a configurable interval and countdown timer.
+- **Retries:** Automatically retries failed requests based on configuration (number of attempts and delay).
+- **Adapters & Mappers:** Supports `adapter` functions to transform incoming data and `mapper` functions for outgoing payloads.
+- **Streaming:** Handles streaming responses when configured.
+- **Error Handling:** Centralized error handling with optional Toast notifications.
+- **CRUD Support:** Provides methods for `getRequest`, `postRequest`, `putRequest`, `deleteRequest`, and `downloadRequest`.
+
+**Usage:**
+Inject `HTTPManagerService` to make API requests. It handles loading state, errors, and data updates via Observables.
+
+#### API Request Options (`ApiRequest`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `server` | `string` | The base URL for the request. | `''` |
+| `path` | `any[]` | Path segments to append to the URL. | `[]` |
+| `headers` | `any` | Custom headers for the request. | `{}` |
+| `adapter` | `function` | Function to transform the response data. | `undefined` |
+| `mapper` | `function` | Function to transform the request payload. | `undefined` |
+| `polling` | `number` | Polling interval in seconds (0 = disabled). | `0` |
+| `retry` | `RetryOptions` | Retry configuration. | `{ times: 0, delay: 3 }` |
+| `stream` | `boolean` | Enable streaming response handling. | `false` |
+| `displayError` | `boolean` | Show toast notification on error. | `false` |
+| `saveAs` | `string` | Filename for file downloads. | `undefined` |
+| `ws` | `WSOptions` | WebSocket configuration options. | `undefined` |
+
+#### Example
+
+```typescript
+export class MyComponent {
+  httpManager = inject(HTTPManagerService);
+
+  data$ = this.httpManager.data$;
+  isLoading$ = this.httpManager.isPending$;
+  error$ = this.httpManager.error$;
+
+  fetchData() {
+    const options = ApiRequest.adapt({
+      path: ['users'],
+      polling: 5, // Poll every 5 seconds
+      retry: { times: 3, delay: 1 },
+      adapter: User.adapt // Transform response to User model
+    });
 
-Http service simplifies http requests in the following ways
-  - Define a fixed endpoint service
-  - Provide a fixed set of headers or add to the headers on request
-  - Proxy Config Support
-  - Adapter for strict type checking for incoming data
-  - Mapper for data transformation for outgoing data
-  - Polling requests automatically
-  - Retry requests if failure
-  - Stream http requests from endpoint service
-  - Display Error provides a Toast (Snackbar) notification on error
+    this.httpManager.getRequest(options).subscribe();
+  }
+}
+```
 
-### HTTP State Manager Service
+#### Advanced Features
+
+| Feature | Description | Configuration |
+| :--- | :--- | :--- |
+| **Streaming** | Handle streaming responses (e.g., NDJSON). | Set `stream: true` in `ApiRequest`. |
+| **Polling** | Automatically poll the endpoint at a specified interval. | Set `polling: number` (seconds) in `ApiRequest`. |
+| **Retry** | Automatically retry failed requests. | Configure `retry: { times: 3, delay: 3 }` in `ApiRequest`. |
+| **Adapters** | Transform incoming API response data before it reaches the state. | Use `adapter: (data) => transformedData` in `ApiRequest`. |
+| **Mappers** | Transform outgoing payload data before sending to the API. | Use `mapper: (data) => transformedData` in `ApiRequest`. |
+
+```typescript
+const options = ApiRequest.adapt({
+  path: ['users'],
+  polling: 5, // Poll every 5 seconds
+  retry: { times: 3, delay: 1 },
+  adapter: User.adapt // Transform response to User model
+});
+```
 
-Http service simplifies http request state management in the following ways
-  - Inherits from HTTP Manager Service for config options
-  - Creates a Component Store state (NGRX)
-  - Selectors for data and selecting data records
-  - Create, Update and Delete automatically updates data by endpoint and state on success
-  - Get keeps state of records
+### 2. Request Manager Signal Service (`HTTPManagerSignalsService`)
+**Path:** `request-manager-services/http-manager-signals.service.ts`
 
-### Database Storage Manager (Coming soon)
-  - Inherits from HTTP State Manager Service for config options
-  - Manages HTTP Requests caching data in local DB (IndexedDB) using DixieJS
-  - Requests check first local DB and if data is not stale, request is made and updates DB
-  - Expiry time/date can be set for DB records for caching
+A modern alternative to `HTTPManagerService` using Angular Signals for state management.
 
-### Local/Session Storage
-  - Allows for Local and Storage management for data Persistence
-  - Component Store (NGRX) State for changes on storage
-  - Encryption for data
-  - Expiry time/date can be set for stores
+**What it does:**
+This service provides the same functionality as `HTTPManagerService` but exposes state using Angular Signals instead of RxJS Observables. This is ideal for modern Angular applications leveraging fine-grained reactivity.
 
-## Using the Services
+**Features:**
+- **Signal-Based State:** Exposes `data`, `isPending`, `error`, and `countdown` as Signals.
+- **Feature Parity:** Supports all features of `HTTPManagerService` including polling, retries, adapters, and streaming.
+- **Optimized for Signals:** Designed to work seamlessly with Angular's Signal-based components and templates.
 
-There are three ways to use the service, depending on your needs:
+**Usage:**
+Ideal for components using Angular Signals.
 
-### Injecting the Service (Single Usage)
+```typescript
+export class MyComponent {
+  httpManager = inject(HTTPManagerSignalsService);
 
-  ```ts
-  httpManagerService = inject(HTTPManagerService)
-  ```
+  data = this.httpManager.data; // Signal
+  isLoading = this.httpManager.isPending; // Signal
+  error = this.httpManager.error; // Signal
 
-- This approach provides a singleton state for the service, as services are provided in root (@Injectable({ providedIn: 'root' })).
-- Any components or services that inject this service will share the same state, meaning they all have access to:
-  - data$ (observable for data)
-  - isPending$ (loading state)
-  - countDown$ (loading state)
-  - error$ (error state)
-  - Methods associated with the service
-  - Since there is only one shared state, it can be reused across components without creating new instances.
-
-  Here is a very simple example
-
-  ```ts
-    //Define your API request details using the `ApiRequest` adapter
-    const apiOptions = ApiRequest.adapt({
-      server: 'myApiUrl/rest/clients' // or ['myApiUrl', 'rest', 'clients']
-    })
+  fetchData() {
+    const options = ApiRequest.adapt({ path: ['users'] });
+    this.httpManager.getRequest(options).subscribe();
+  }
+}
+```
 
-  onFetchData() {
+### 3. Request Manager State Service (`HTTPManagerStateService`)
+**Path:** `request-manager-state-service/http-manager-state.store.ts`
+
+An extension of `ComponentStore` designed for managing entity state (CRUD) with built-in HTTP request handling and WebSocket integration.
+
+**What it does:**
+This service combines HTTP requests with local state management. It automatically updates the local store when CRUD operations succeed, eliminating the need to manually refresh data. It also integrates with WebSockets to keep the state synchronized with server-side changes.
+
+**Features:**
+- **ComponentStore Integration:** Extends NGRX `ComponentStore` for robust state management.
+- **Automatic CRUD Updates:** `createRecord`, `updateRecord`, and `deleteRecord` automatically update the local state upon success.
+- **WebSocket Sync:** Listens for WebSocket messages to update, create, or delete records in real-time.
+- **Database Support:** Can be configured to use IndexedDB for caching (via `DatabaseStorage`).
+- **Selectors:** Provides selectors like `data$` and `selectRecord$(id)` for easy data access.
+- **Pagination Support:** Includes state for pagination (`page$`, `totalPages$`).
+
+**Usage:**
+Extend this service to create a store for a specific feature. You must call `super()` with `ApiRequest`, `DataType`, and `DatabaseStorage`.
+
+```typescript
+@Injectable()
+export class UsersStore extends HTTPManagerStateService<User> {
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'api',
+        path: ['users'],
+        adapter: User.adapt // Required for Database Storage
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({
+        table: 'users-cache',
+        expiresIn: '1d'
+      })
+    );
+  }
 
-      this.httpManagerService.getRequest<any>(apiOptions)
-      .pipe(
-        catchError(error => {
-          return throwError(() => this.errorHandling(error, 'GET'))
-        })
-      ).subscribe(data => console.log(data)))
+  // Wrap CRUD methods for cleaner component usage
+  getUsers() {
+    this.fetchRecords();
+  }
 
-    }
-  ```
+  addUser(user: User) {
+    this.createRecord(user);
+  }
+}
+```
 
-### Example
-In this example, we define the endpoint URL as myApiUrl. This will return the data from the observable for your use case.
+**Features:**
+- **Automatic State Updates:** `createRecord`, `updateRecord`, and `deleteRecord` automatically update the local state upon success.
+- **Selectors:** `data$`, `selectRecord$(id)`.
+- **WebSocket Integration:** Automatically connects to WS if configured in `ApiRequest`. Syncs state on 'create', 'update', 'delete' events from WS.
+- **Runtime Configuration:** Use `setApiRequestOptions()` to update API or WS settings dynamically.
+
+### 4. Request Manager Signal State Service
+*Note: Currently, the state management service (`HTTPManagerStateService`) is based on `ComponentStore` (RxJS). A dedicated Signal-based state manager is not yet available in this library.*
+
+### 5. Local Storage Manager Service (`LocalStorageManagerService`)
+**Path:** `local-storage-manager-service/local-storage-manager.service.ts`
+
+Manages `localStorage` and `sessionStorage` with encryption and expiration support.
+
+**What it does:**
+This service provides a secure and managed way to interact with browser storage. It treats storage as a state, allowing you to subscribe to changes. It also handles data encryption and expiration automatically.
+
+**Features:**
+- **Encryption:** Encrypts data before saving to storage using `SymmetricalEncryptionService` (requires `APP_ID`).
+- **Expiration:** Supports setting an expiration time (`expiresIn`) for stored items. Automatically cleans up expired items.
+- **Storage Types:** Supports both `localStorage` (Global) and `sessionStorage` (Session).
+- **Reactive:** Exposes storage items as Observables, allowing components to react to storage changes.
+- **Metadata Management:** Keeps track of storage settings (encryption, expiration) separately from the data.
+
+**Usage:**
+```typescript
+localStorageManager = inject(LocalStorageManagerService);
+
+// Create/Set a store
+this.localStorageManager.setStore({
+  name: 'user-settings',
+  data: { theme: 'dark' },
+  options: {
+    storage: StorageType.GLOBAL, // or StorageType.SESSION
+    encrypted: true,
+    expiresIn: '1d'
+  }
+});
 
-The endpoint can be:
+// Select a store (returns data)
+settings$ = this.localStorageManager.store$('user-settings');
 
-A direct URL (e.g., https://apple.com/clients).
-A proxy-config file (recommended to avoid CORS issues).
-A string, an array of strings, or numbers—similar to Angular’s Router.navigate() API.
-The HTTP Service Manager automatically sanitizes the endpoint by removing redundant `/` characters and validating the URL.
+// Select store settings (returns metadata)
+meta$ = this.localStorageManager.setting$('user-settings');
 
-You can also add query parameters by passing an object:
+// Reset all stores
+this.localStorageManager.resetStore();
+```
 
-  ```ts
-    { sortBy: 'asc', filter: ['samples', 'testing'] }
-  ```
+### 6. Store State Manager Service (`StoreStateManagerService`)
+**Path:** `store-state-manager-service/store-state-manager.service.ts`
+
+A service that extends `ComponentStore` to provide persistent state management synchronized with local or session storage.
+
+**What it does:**
+This service bridges the gap between in-memory state (ComponentStore) and persistent storage. It ensures that your state is automatically saved to storage when it changes and restored from storage when the service is initialized.
+
+**Features:**
+- **Persistence:** Automatically saves state changes to `localStorage` or `sessionStorage`.
+- **State Restoration:** Restores state from storage on initialization.
+- **Reactivity:** Extends `ComponentStore`, providing all its benefits (selectors, updaters, effects).
+- **Encryption Support:** Leverages `LocalStorageManagerService` for optional encryption.
+- **Model Adaptation:** Supports using a model adapter to ensure state structure.
+
+**Usage:**
+Extend this service to create a persistent store.
+
+```typescript
+@Injectable({
+  providedIn: 'root'
+})
+export class SettingsStateService extends StoreStateManagerService {
+
+  constructor() {
+    super(
+      StateStorageOptions.adapt({
+        store: 'my-settings-store', // Unique store name
+        options: SettingOptions.adapt({
+          storage: StorageType.SESSION, // or StorageType.GLOBAL (Local Storage)
+          encrypted: false
+        }),
+        model: Settings.adapt, // Model adapter for initial state
+      })
+    );
+  }
 
-This translates to: `https://apple.com/clients?sortBy=asc&filter=samples,testing`
+  // Update specific part of state
+  updateSetting(value: any) {
+    this.updateData(value);
+  }
 
-There are a number of other options available in the `ApiRequest` adapter
+  // Select specific part of state
+  getSetting(key: string) {
+    return this.data$.pipe(map(state => state[key]));
+  }
+}
+```
 
+**Features:**
+- **Persistence:** Automatically saves state changes to LocalStorage or SessionStorage.
+- **Reactivity:** Extends `ComponentStore`, providing `data$` selector and `updater` methods.
+- **Encryption:** Supports encrypted storage via `LocalStorageManagerService`.
 
-### Extending a Component or Service with the Service (Multiple Instances - preferred method)
+### 7. WebSocket Manager Service (`WebsocketService`)
+**Path:** `ws-manager-service/services/websocket.service.ts`
 
-This approach creates a new instance of the service for each component or service that extends it, ensuring each instance maintains its own independent state.
+Handles WebSocket connections, channel subscriptions, and messaging. It is used internally by `HTTPManagerStateService` but can be used standalone.
 
-### Observables
-- Similar to the first approach, instead of one instance of the state you are creating a new state instance
-- CRUD operations return Observables, similar to HttpClient.
-- This allows for custom error handling and executing additional actions after the request completes.
-- Since HTTP requests are asynchronous, you must subscribe to the Observable to receive data:
+**What it does:**
+This service manages the lifecycle of a WebSocket connection. It handles authentication, connection stability, and message routing. It supports a channel-based architecture for organizing communication.
 
-  ```ts
-    myService.getData().subscribe(response => {
-      console.log(response);
-    });
-  ```
+**Features:**
+- **Connection Management:** Handles connecting, disconnecting, and reconnecting.
+- **Authentication:** Supports JWT-based authentication for secure connections.
+- **Channels:** Allows subscribing and unsubscribing to specific channels.
+- **Messaging:** Supports sending messages to specific channels, users, or broadcasting to all.
+- **Observables:** Exposes `messages$` stream and `connectionStatus$` for reactive integration.
 
-- Alternatively, you can use the async pipe for automatic subscription and cleanup:
+**Usage:**
+```typescript
+wsService = inject(WebsocketService);
 
-  ```ts
-    {{ myData$ | async }}
-  ```
+// Connect
+this.wsService.connect('wss://api.example.com/ws', 'jwt-token');
 
-### Example
-First we need to extend the Component or Service (recommended approach) with the `HTTPManagerService`
+// Subscribe to channel
+this.wsService.subscribeToChannel('my-channel');
 
-Component Example:
-  ```ts
-  export class RequestManagerDemoComponent extends HTTPManagerService<any> implements OnInit {
+// Listen to messages
+this.wsService.messages$.subscribe(msg => console.log(msg));
 
-    constructor() { 
-      super()
-    }
-  }
-  ```
-
-Service Example:
-  ```ts
-  @Injectable({
-    providedIn: 'root'
-  })
-  export class myAPIService extends HTTPManagerService<any> {
-
-    constructor() { 
-      super()
-    }
+// Send Message
+this.wsService.sendMessageInChannel('my-channel', { text: 'hello' });
+```
 
+#### WebSocket Options (`WSOptions`)
+
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `id` | `string` | Unique identifier for the WebSocket connection. | `''` |
+| `wsServer` | `string` | The WebSocket server URL. | `''` |
+| `jwtToken` | `string` | JWT token for authentication. | `''` |
+| `permissions` | `string[]` | List of permissions associated with the connection. | `[]` |
+| `channels` | `string[]` | List of channels to subscribe to upon connection. | `undefined` |
+| `userAdapter` | `WSUser` | Adapter for mapping user data. | `undefined` |
+| `retry` | `RetryOptions` | Retry configuration for connection attempts. | `undefined` |
+
+#### Integration with HTTPManagerStateService
+
+You can configure `HTTPManagerStateService` to automatically handle WebSocket connections by providing `ws` options in `ApiRequest`.
+
+```typescript
+@Injectable()
+export class UsersStore extends HTTPManagerStateService<User> {
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'api',
+        path: ['users'],
+        // WebSocket Configuration
+        ws: {
+          id: 'WS-USERS',
+          wsServer: 'wss://api.example.com/ws',
+          jwtToken: 'your-token',
+          wsChannels: ['allChannels'],
+          retry: { times: 3, delay: 5 }
+        }
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt()
+    );
   }
-  ```
-
-In this example, we define the endpoint URL as myApiUrl. This will return the data from the observable for your use case.
-
-The endpoint can be:
-
-A direct URL (e.g., https://apple.com/clients).
-A proxy-config file (recommended to avoid CORS issues).
-A string, an array of strings, or numbers—similar to Angular’s Router.navigate() API.
-The HTTP Service Manager automatically sanitizes the endpoint by removing redundant `/` characters and validating the URL.
-
-You can also add query parameters by passing an object:
-```ts
-  { sortBy: 'asc', filter: ['samples', 'testing'] }
+}
 ```
-This translates to: `https://apple.com/clients?sortBy=asc&filter=samples,testing`
 
-Lets define these query params as a variable called `PARAMS` and use them in the following request.
+### 8. Database Manager Service (`DatabaseManagerService`)
 
-There are a number of other options available in the `ApiRequest` adapter
+**Path:** `database-manager-service/database.manager.service.ts`
 
-No we can define a method:
-In this example take note that the clientID has been passed to the method and the param after the apiOptions allows for further customization for the api request being made. In this case we extended the the base path defined in the `ApiRequest` options. We also added the `PARAMS` for query parameters.
+A wrapper service for Dexie.js to manage IndexedDB interactions using RxJS Observables.
 
-Define your API request options using the 'ApiRequest' adapter
+**What it does:**
 
-  ```ts
-    const apiOptions = ApiRequest.adapt({
-      server: ['myApiUrl', 'rest', 'clients']
-    })
+This service simplifies interactions with IndexedDB by providing a clean, Observable-based API. It handles database initialization, table creation, and all standard CRUD operations. It is designed to work seamlessly with the `HTTPManagerStateService` for caching but can also be used independently.
 
-    // Dynamically change these params
-    const PARAMS = {
-      sortBy: 'asc',
-      filter: ['samples', 'testing']
-    }
+**Features:**
 
-    onFetchData(clientId) {
+- **Table Management:** Create and manage database tables with flexible schemas.
+- **CRUD Operations:** Full support for Create, Read, Update, and Delete operations on single or multiple records.
+- **Querying:** Find records by specific column values.
+- **Bulk Operations:** Optimized methods for creating and deleting multiple records at once.
+- **Schema Inspection:** Methods to check for table existence and retrieve schema definitions.
 
-      this.httpManagerService.getRequest<any>(apiOptions, [clientId, this.PARAMS])
-      .pipe(
-        catchError(error => {
-          return throwError(() => this.errorHandling(error, 'GET'))
-        })
-      ).subscribe(data => console.log(data)))
+**Usage:**
 
-    }
-  ```
+```typescript
+dbManager = inject(DatabaseManagerService);
 
+// 1. Initialize Table
+const tableDef = TableSchemaDef.adapt({
+  table: 'users',
+  schema: '++id, name, age' // Dexie.js schema syntax
+});
 
-### State Observable
-- When executing CRUD operations, their results are automatically pushed into the data$ observable within the service.
-- This means you can bind the data$ observable to a component to automatically update UI elements.
-- Using this approach enables state management across components and allows data refresh actions without needing additional logic.
+this.dbManager.createDatabaseTable(tableDef).subscribe(() => {
+  console.log('Table initialized');
+});
 
-### Example
-First we need to extend the Component or Service (recommended approach) with the `HTTPManagerService`
+// 2. CRUD Operations
+// Create
+this.dbManager.createTableRecord('users', { name: 'John', age: 30 }).subscribe();
 
-Component Example:
-The structure would be: Component extends `HTTPManagerService`
+// Read
+this.dbManager.getTableRecords('users').subscribe(users => console.log(users));
+this.dbManager.getTableRecord('users', 1).subscribe(user => console.log(user));
 
-  ```ts
-  export class RequestManagerDemoComponent extends HTTPManagerService<any> implements OnInit {
+// Update
+this.dbManager.updateTableRecord('users', { id: 1, name: 'John Doe', age: 31 }).subscribe();
 
-    constructor() { 
-      super()
-    }
-  }
-  ```
+// Delete
+this.dbManager.deleteTableRecord('users', 1).subscribe();
 
-Service Example:
-The structure would be: Component injects a service call `clientsService` and `clientsService` extends `HTTPManagerService`
+// 3. Bulk Operations
+const users = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 28 }];
+this.dbManager.createTableRecords('users', users).subscribe();
 
-  ```ts
-  @Injectable({
-    providedIn: 'root'
-  })
-  export class myAPIService extends HTTPManagerService<any> {
+// 4. Querying
+this.dbManager.findTableRecords('users', 'age', 25).subscribe(results => console.log(results));
 
-    constructor() { 
-      super()
-    }
+// 5. Metadata
+this.dbManager.hasDatabaseTable('users').subscribe(exists => console.log(exists));
+```
 
-  }
-  ```
+#### Database Storage Configuration (`DatabaseStorage`)
 
-In this example, we define the endpoint URL as myApiUrl.
+When using `HTTPManagerStateService`, you can configure local database caching using `DatabaseStorage.adapt()`.
 
-Lets define these query params as a variable called `PARAMS` and use them in the following request.
+##### Options
 
-No we can define a method:
-In this example the clientID has been passed to the method. 
-We also added the `PARAMS` for query parameters.
+| Option | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `table` | `string` | The name of the table in IndexedDB where records will be stored. | `''` |
+| `expiresIn` | `string` | The duration for which the data remains valid. Format: `'1d'` (days), `'1h'` (hours), `'30m'` (minutes). | `''` |
 
-Define your API request options using the 'ApiRequest' adapter
+##### Example
 
-  ```ts
-    const apiOptions = ApiRequest.adapt({
-      server: ['myApiUrl', 'rest', 'clients']
-    })
+```typescript
+import { DatabaseStorage } from 'http-request-manager';
 
-    // Dynamically change these params
-    const PARAMS = {
-      sortBy: 'asc',
-      filter: ['samples', 'testing']
-    }
+const dbConfig = DatabaseStorage.adapt({
+  table: 'my-feature-cache',
+  expiresIn: '6h' // Cache expires in 6 hours
+});
+```
 
-    onFetchData(clientId: number) {
-      this.httpManagerService.getRequest<any>(apiOptions, [clientId, this.PARAMS]).subscribe()
-    }
-  ```
+### 9. Utils (`UtilsService`)
+**Path:** `utils/utils.service.ts`
 
-  In the above case we are not using the data returning from the Observable but rather executing the api call, like a refresh if called again
+Provides utility functions for common tasks.
 
-  To access the data from the observable, you need to bind the observable if your using a component that injects the service that extends the `HTTPManagerService`
+**What it does:**
+A collection of helper functions used throughout the library and available for application use. It simplifies common tasks related to data manipulation, validation, and time calculations.
 
-  In the component where the service was injected, we define
+**Features:**
+- **JSON Handling:** Safe `stringToJSON` and `JSONToString` methods.
+- **Type Checking:** `isString`, `isObject`, `isJSON`.
+- **Expiration:** `expires(string)` converts duration strings (e.g., '1d', '2h') to epoch timestamps. `hasExpired(timestamp)` checks if a timestamp has passed.
+- **Conversions:** `base32ToHex`, `binaryToHex`.
+- **Object Equality:** `objectsEqual` for deep comparison.
 
-  ```ts
-    data$ = this.clientsService.data$
-    isPending$ = this.clientsService.isPending$
-    error$ = this.clientsService.error$
-  ```
-  By doing this gives your component the state of the data and other feedback states for the request that now you can use in your template.
+**Usage:**
+```typescript
+utils = inject(UtilsService);
 
-```ts
-  {{ data$ | async }}
-  {{ isPending$ | async }}
-  {{ error$ | async }}
-```
+// Check expiration
+const isExpired = this.utils.hasExpired(expiryTimestamp);
 
+// Convert JSON
+const json = this.utils.stringToJSON(jsonString);
 
-### ApiRequest Options
-The following are the available options when configuring an ApiRequest object:
-
-```ts
-apiRequest = ApiRequest.adapt({
-  server: string,
-  path: any[],
-  headers: any,
-  adapter?: any,
-  mapper?: any,
-  polling?: number, // in seconds (undefined | 0 = none)
-  retry: RetryOptions,
-  stream?: boolean
-  displayError: boolean
-});
+// Calculate Expiry
+const expiryEpoch = this.utils.expires('1d'); // Returns epoch for 1 day from now
 ```
 
-| **Property**   | **Description**                                                                   | **Type**                   | **Required** |
-|--------------|--------------------------------------------------------------------------------|---------------------------|------------|
-| `server`     | The base URL or service endpoint for the API request.                         | `string`                   | ✅         |
-| `path`       | Additional paths to append to the base URL for constructing the full API endpoint. | `any[]`                    | ✅         |
-| `headers`    | Custom headers to include in the request, provided as an object.             | `any`                      | ✅         |
-| `adapter`    | A model adapter used to transform incoming data (e.g., `DistrictData.adapt`). | `any`                      | ❌         |
-| `mapper`     | A model adapter used to map outgoing data before sending it to the server (e.g., `DistrictData.mapper`). | `any` | ❌         |
-| `polling`    | Enables periodic polling, where the request will be made every specified number of seconds. | `number` (seconds)         | ❌         |
-| `retry`      | Retry logic using `RetryOptions`, which includes: <br> - `times`: Number of retry attempts. <br> - `delay`: Delay in milliseconds between retries. | `RetryOptions`             | ✅         |
-| `stream`     | A flag to indicate whether the request expects a stream of data from the server. | `boolean`                  | ❌         |
-| `displayError` | A flag to indicate whether to present the error from the request in a snackbar notification. | `boolean`                  | ✅         |
-
-
-### Additional Observables for Request Status
-- countdown$: If polling is active, this property gives feedback on when the next request will take place. It starts from the specified time in seconds and counts down to 0, triggering the next request and restarting the countdown.
-- error$: This returns any HTTP error that occurs during the request.
-- isPending$: This boolean value indicates whether the request is pending (true) or has been completed (false).
-- data$: You can access the data fetched in the request using the data$ observable. This provides the response from the server, which can be used for further processing or displaying in the UI.
+---
 
-## Importing Module forRoot() Configuration
+## Available Interceptors
 
-
-# Available Interceptors
-
-There are 3 interceptors that you can import into your project for api requests. 
+There are 3 interceptors that you can import into your project for api requests.
 
 You may add these interceptors in your `AppModule` file as providers and import them into as providers.
 
-```ts
+```typescript
 providers: [
   { provide: HTTP_INTERCEPTORS, useClass: WithCredentialsInterceptor, multi: true },
   { provide: HTTP_INTERCEPTORS, useClass: RequestHeadersInterceptor, multi: true },
@@ -343,9 +566,9 @@ This interceptor handles errors of type 400 and 500. This interceptor is applica
 
 - **WithCredentialsInterceptor**
 
-  Adds to your request header 
+  Adds to your request header
 
-  ```json 
+  ```json
   { credentials: true }
   ```