http-request-manager 18.7.12 → 18.7.14

package/README.md

@@ -1,44 +1,128 @@
-# HTTP Request Manager - Angular Library
+# Request Manager Service Documentation
 
-[![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=flat&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Angular](https://img.shields.io/badge/Angular-DD0031?style=flat&logo=angular&logoColor=white)](https://angular.io/)
-[![RxJS](https://img.shields.io/badge/RxJS-B7178C?style=flat&logo=reactivex&logoColor=white)](https://rxjs.dev/)
+## Overview
 
-A comprehensive Angular library providing enterprise-grade HTTP request management, state management, real-time communication, and local data persistence.
-
-## 🚀 Features
+The `http-request-manager` is a comprehensive Angular library that provides enterprise-grade HTTP request management, state management, real-time communication, and local data persistence. It simplifies complex data flows and provides a unified API for handling HTTP, WebSocket, and storage operations.
 
 ### Core Capabilities
 
-| Feature | Description | Service |
-|---------|-------------|---------|
-| **🌐 HTTP Request Management** | Observable-based & Signal-based HTTP services with retry logic, polling, and streaming | [`HTTPManagerService`](services/http-manager/README.md) |
-| **🔄 State Management** | ComponentStore integration with automatic CRUD state updates | [`HTTPManagerStateService`](services/http-state/README.md) |
-| **💬 Real-Time Communication** | WebSocket messaging with channel-based architecture | [`WebSocketService`](services/websocket/README.md) |
-| **💾 Data Persistence** | LocalStorage/SessionStorage with encryption & IndexedDB caching | [`LocalStorageManagerService`](services/local-storage/README.md) |
-| **🗄️ Database Management** | IndexedDB integration via Dexie.js with Observable API | [`DatabaseManagerService`](services/database/README.md) |
-| **⚡ Utility Functions** | JSON handling, expiration, conversions, and validation | [`UtilsService`](services/utils/README.md) |
+#### 🌐 HTTP Request Management
+
+- **Observable-based** service (`HTTPManagerService`) for reactive programming
+- **Signal-based** service (`HTTPManagerSignalsService`) for modern Angular applications
+- Automatic retry logic with configurable attempts and delays
+- Polling support with countdown timers
+- Streaming response handling (NDJSON, Server-Sent Events)
+- Request/response adapters and mappers for data transformation
+- Built-in error handling with optional toast notifications
+- File download support with progress tracking
+
+#### 🔄 State Management
+
+- **ComponentStore integration** (`HTTPManagerStateService`) for robust state management
+- Automatic CRUD state updates (Create, Read, Update, Delete)
+- Built-in selectors for data access and filtering
+- Pagination support with state tracking
+- Real-time state synchronization via WebSocket
+- IndexedDB caching for offline-first applications
+- Persistent state with LocalStorage/SessionStorage
+
+#### 💬 Real-Time Communication (WebSocket)
+
+- **Dual-mode messaging system:**
+  - **Messaging (PUB- channels)**: Real-time chat/collaboration
+  - **Notifications (MES- channels)**: Database-persisted notifications with date-range queries
+- Automatic reconnection with exponential backoff
+- JWT authentication support
+- Channel-based architecture (STATE, MESSAGE, NOTIFICATION)
+- Subscribe/unsubscribe to channels dynamically
+- Broadcast, channel, and user-specific messaging
+- Connection status monitoring
+- Session persistence across reconnections
+
+#### 💾 Data Persistence
+
+- **LocalStorage/SessionStorage** with encryption and expiration
+- **IndexedDB** integration via Dexie.js for complex queries
+- Automatic cache invalidation based on time
+- Secure encryption using symmetrical encryption service
+- Reactive storage observables for UI synchronization
+
+#### 🎯 Advanced Features
+
+- Request interception (credentials, headers, error handling)
+- Automatic loading state management
+- Database-backed notification history with epoch filtering
+- Define and load previous day's notification channels
+- Bulk operations for IndexedDB
+- Model adapters for type safety
+- Configurable global defaults via `forRoot()`
 
 ### Key Benefits
 
-- ✅ **Type-Safe** - Full TypeScript support with generics
-- ✅ **Offline-First** - Built-in IndexedDB caching
-- ✅ **Real-Time Ready** - Seamless WebSocket integration
-- ✅ **Secure** - Encryption support for sensitive data
-- ✅ **Scalable** - ComponentStore-based architecture
-- ✅ **Flexible** - Works with Observables or Signals
+✅ **Reduced Boilerplate** - Eliminates repetitive HTTP and state management code  
+✅ **Type-Safe** - Full TypeScript support with generics  
+✅ **Offline-First** - Built-in IndexedDB caching for resilient applications  
+✅ **Real-Time Ready** - Seamless WebSocket integration with state management  
+✅ **Secure** - Encryption support for sensitive local data  
+✅ **Scalable** - ComponentStore-based architecture for complex state  
+✅ **Flexible** - Works with Observables or Signals based on preference  
+✅ **Battle-Tested** - Production-ready with comprehensive error handling  
+
+### Use Cases
+
+| Scenario | Solution |
+|----------|----------|
+| Simple API calls with loading states | `HTTPManagerService` |
+| Modern reactive UI with Signals | `HTTPManagerSignalsService` |
+| CRUD operations with auto state sync | `HTTPManagerStateService` |
+| Real-time chat/collaboration | `HTTPManagerStateService` + WebSocket (PUB- channels) |
+| Persistent notifications/alerts | `HTTPManagerStateService` + WebSocket (MES- channels) |
+| User preferences/settings | `LocalStorageManagerService` |
+| Offline-first data access | `DatabaseManagerService` + `HTTPManagerStateService` |
+| Large local datasets | `DatabaseManagerService` with Dexie.js |
+| Polling for live updates | `HTTPManagerService` with polling |
+| File downloads | `HTTPManagerService.downloadRequest()` |
+
+---
+
+## Demo Component (`HttpRequestServicesDemoComponent`)
+
+The `HttpRequestServicesDemoComponent` is a comprehensive demonstration component that showcases the various services available in the `http-request-manager` library. It allows you to interactively test and visualize the functionality of HTTP services, state management, WebSockets, and local storage.
+
+### Usage
+
+To use the demo component in your application, simply add the selector to your template and provide the necessary inputs.
+
+```html
+<app-http-request-services-demo
+  [server]="'http://localhost:8080'"
+  [wsServer]="'ws://localhost:8080'"
+  [jwtToken]="'your-jwt-token'"
+  [adapter]="myAdapterFunction"
+  [mapper]="myMapperFunction">
+</app-http-request-services-demo>
+```
+
+### Inputs
+
+| Input | Type | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `server` | `string` | The base URL for HTTP requests used in the demo. | `'http://localhost:8080'` |
+| `wsServer` | `string` | The WebSocket server URL for testing WS connections. | `'ws://localhost:8080'` |
+| `jwtToken` | `string` | A JWT token used for authenticating WebSocket connections. | `''` |
+| `adapter` | `Function` | An optional adapter function to transform incoming API data. | `undefined` |
+| `mapper` | `Function` | An optional mapper function to transform outgoing request payloads. | `undefined` |
 
-## 📋 Table of Contents
+---
+
+## Summary
 
-- [Quick Start](#quick-start)
-- [Configuration](#configuration)
-- [Services Overview](#services-overview)
-- [Architecture](#architecture)
-- [Interceptors](#interceptors)
-- [Demo Examples](#demo-examples)
-- [Migration Guide](#migration-guide)
+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.
+
+---
 
-## 🚀 Quick Start
+## Quick Start Guide
 
 ### Installation & Setup (2 minutes)
 
@@ -76,9 +160,9 @@ import { APP_ID } from '@angular/core';
 export class AppModule { }
 ```
 
-### Simple Examples
+### Quick Examples
 
-#### Basic HTTP Request
+#### Example 1: Simple HTTP GET Request
 
 ```typescript
 import { Component, inject } from '@angular/core';
@@ -107,9 +191,18 @@ export class UsersComponent {
 }
 ```
 
-#### State Management with CRUD
+#### Example 2: State Management with CRUD
 
 ```typescript
+import { Injectable } from '@angular/core';
+import { HTTPManagerStateService, ApiRequest, DataType } from 'http-request-manager';
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
 @Injectable({ providedIn: 'root' })
 export class UsersStore extends HTTPManagerStateService<User> {
   
@@ -146,11 +239,288 @@ export class UsersComponent {
 }
 ```
 
-## ⚙️ Configuration
+#### Example 3: WebSocket Real-Time Messaging
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class ChatStore extends HTTPManagerStateService<Message> {
+  
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'http://localhost:8080',
+        path: ['messages'],
+        ws: {
+          id: 'CHAT_WS',
+          wsServer: 'ws://localhost:8080',
+          jwtToken: ''  // Add token if needed
+        }
+      }),
+      DataType.ARRAY
+    );
+  }
+
+  joinChat(channel: string) {
+    this.createChannel(channel);
+    this.subscribeToChannel(channel);
+  }
+
+  sendMessage(channel: string, text: string, user: any) {
+    this.wsMessaging(
+      ChannelMessage.adapt({
+        sessionId: user,
+        content: { message: text }
+      }),
+      [channel]
+    );
+  }
+}
+
+// Component
+@Component({
+  template: `
+    <div *ngFor="let msg of chatStore.communicationMessages$ | async">
+      {{ msg.content.message }}
+    </div>
+    <input [(ngModel)]="messageText">
+    <button (click)="send()">Send</button>
+  `
+})
+export class ChatComponent {
+  chatStore = inject(ChatStore);
+  messageText = '';
+
+  ngOnInit() {
+    this.chatStore.joinChat('general');
+  }
+
+  send() {
+    this.chatStore.sendMessage('general', this.messageText, {
+      id: 1,
+      name: 'John'
+    });
+    this.messageText = '';
+  }
+}
+```
+
+#### Example 4: Persistent Notifications with Database
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class NotificationStore extends HTTPManagerStateService<any> {
+  
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'http://localhost:8080',
+        ws: {
+          id: 'NOTIFICATIONS',
+          wsServer: 'ws://localhost:8080'
+        }
+      }),
+      DataType.ARRAY
+    );
+  }
+
+  initNotifications(user: any) {
+    // Get today's notification channels
+    this.getTodaysNotificationChannels();
+    
+    // Subscribe to alerts with 24h history
+    this.subscribeToNotificationChannel('alerts', {
+      startEpoch: Math.floor(Date.now() / 1000) - 86400
+    }, user);
+  }
+
+  sendAlert(message: string, priority: 'low' | 'high') {
+    this.sendNotification('alerts', {
+      message,
+      priority,
+      timestamp: Date.now()
+    });
+  }
+
+  loadPreviousDayChannels() {
+    this.definePreviousNotificationChannels();
+  }
+}
+
+// Component
+@Component({
+  template: `
+    <div *ngFor="let notif of store.notificationMessages$ | async">
+      <strong>{{ notif.user_name }}</strong>: {{ notif.content.message }}
+      <span>{{ notif.created * 1000 | date:'short' }}</span>
+    </div>
+    <button (click)="store.loadPreviousDayChannels()">
+      Load Previous Day Channels
+    </button>
+  `
+})
+export class NotificationsComponent {
+  store = inject(NotificationStore);
+
+  ngOnInit() {
+    this.store.initNotifications({
+      id: 1,
+      name: 'John',
+      email: 'john@example.com'
+    });
+  }
+}
+```
+
+#### Example 5: Local Storage with Encryption
+
+```typescript
+import { Component, inject } from '@angular/core';
+import { LocalStorageManagerService, SettingOptions } from 'http-request-manager';
+
+@Component({
+  selector: 'app-settings'
+})
+export class SettingsComponent {
+  storage = inject(LocalStorageManagerService);
+
+  saveSettings(settings: any) {
+    this.storage.setItem(
+      'user-preferences',
+      settings,
+      SettingOptions.adapt({
+        encrypted: true,
+        expiresIn: '30d'
+      })
+    );
+  }
+
+  loadSettings() {
+    return this.storage.getItem('user-preferences');
+  }
+
+  clearSettings() {
+    this.storage.removeItem('user-preferences');
+  }
+}
+```
+
+#### Example 6: IndexedDB Caching for Offline-First
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class ProductStore extends HTTPManagerStateService<Product> {
+  
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'http://localhost:8080',
+        path: ['products'],
+        adapter: (data: any) => data as Product  // Required for DB
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({
+        table: 'products-cache',
+        expiresIn: '1d'  // Cache for 1 day
+      })
+    );
+  }
+
+  loadProducts() {
+    // First checks IndexedDB cache, then fetches from server if expired
+    this.fetchRecords();
+  }
+}
+```
+
+#### Example 7: Polling for Live Updates
+
+```typescript
+export class StatusComponent {
+  httpManager = inject(HTTPManagerService);
+  
+  status$ = this.httpManager.data$;
+  countdown$ = this.httpManager.countdown$;
+
+  ngOnInit() {
+    this.httpManager.getRequest(
+      ApiRequest.adapt({
+        path: ['server-status'],
+        polling: 10  // Poll every 10 seconds
+      })
+    ).subscribe();
+  }
+
+  ngOnDestroy() {
+    this.httpManager.stopPolling();
+  }
+}
+```
+
+### Common Use Cases
+
+| Use Case | Service to Use | Key Features |
+|----------|---------------|--------------|
+| Simple API calls | `HTTPManagerService` | Observables, retry, polling |
+| Modern reactive UI | `HTTPManagerSignalsService` | Angular Signals |
+| CRUD operations | `HTTPManagerStateService` | Auto state updates |
+| Real-time chat | `HTTPManagerStateService` + WS | Messaging channels |
+| Persistent notifications | `HTTPManagerStateService` + WS | Database-backed |
+| User preferences | `LocalStorageManagerService` | Encryption, expiration |
+| Offline-first | `DatabaseManagerService` | IndexedDB |
+| Large local datasets | `DatabaseManagerService` | Querying, indexing |
+
+---
+
+## 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`)
 
-### Module Initialization (`forRoot`)
+| 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` |
 
-Configure the library globally using the `forRoot` method:
+#### Example
 
 ```typescript
 import { HttpRequestManagerModule } from 'http-request-manager';
@@ -173,254 +543,943 @@ import { HttpRequestManagerModule } from 'http-request-manager';
         }
       }
     })
-  ]
+  ],
+  // ...
 })
 export class AppModule { }
 ```
 
-### Configuration Options
+### 2. AppService Initialization
 
-#### HTTP Options (`ConfigHTTPOptions`)
+The `AppService` (used by `LocalStorageManagerService` for encryption) requires a unique `APP_ID` to be provided in your `AppModule`.
 
-| Option | Type | Description | Default |
-|--------|------|-------------|---------|
-| `server` | `string` | Base URL for API requests | `''` |
-| `path` | `any[]` | Default path segments | `[]` |
-| `headers` | `any` | Default headers | `{}` |
-| `polling` | `number` | Default polling interval (seconds) | `0` |
-| `retry` | `RetryOptions` | Default retry configuration | `{ times: 0, delay: 3 }` |
-| `stream` | `boolean` | Enable streaming by default | `false` |
-| `displayError` | `boolean` | Show toast errors by default | `false` |
+```typescript
+import { APP_ID } from '@angular/core';
 
-#### Local Storage Options (`LocalStorageOptions`)
+@NgModule({
+  providers: [
+    {
+      provide: APP_ID,
+      useValue: "your-unique-guid-here", // e.g., "056991ac-3537-43ab-b5b9-83edf6554eff"
+    },
+    // ...
+  ],
+  // ...
+})
+export class AppModule { }
+```
 
-| Option | Type | Description | Default |
-|--------|------|-------------|---------|
-| `storageName` | `string` | Key for storing data | `'storage'` |
-| `storageSettingsName` | `string` | Key for settings metadata | `'global-storage'` |
-| `options` | `SettingOptions` | Default storage settings | `{ storage: StorageType.GLOBAL, expires: 0, expiresIn: '', encrypted: false }` |
+## Services Documentation
 
-#### Retry Options (`RetryOptions`)
+### 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 |
-|--------|------|-------------|---------|
-| `times` | `number` | Number of retry attempts | `0` |
-| `delay` | `number` | Delay between retries (seconds) | `3` |
-
-## 📚 Services Overview
-
-| Service | Description | Use Case |
-|---------|-------------|----------|
-| [`HTTPManagerService`](services/http-manager/README.md) | Observable-based HTTP client | Simple API calls with loading states |
-| [`HTTPManagerSignalsService`](services/http-signals/README.md) | Signal-based HTTP client | Modern reactive UI with Angular Signals |
-| [`HTTPManagerStateService`](services/http-state/README.md) | ComponentStore with HTTP & WebSocket | CRUD operations with auto state sync |
-| [`WebsocketService`](services/websocket/README.md) | WebSocket connection management | Real-time messaging and notifications |
-| [`LocalStorageManagerService`](services/local-storage/README.md) | Secure local storage | User preferences, session data |
-| [`DatabaseManagerService`](services/database/README.md) | IndexedDB wrapper | Offline-first data access |
-| [`StoreStateManagerService`](services/store-state-manager/README.md) | Persistent ComponentStore | Application state persistence |
-| [`UtilsService`](services/utils/README.md) | Utility functions | JSON handling, expiration, conversions |
+| :--- | :--- | :--- | :--- |
+| `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` |
+
+#### HTTPManagerService Example
 
-### Common Use Cases
+```typescript
+export class MyComponent {
+  httpManager = inject(HTTPManagerService);
 
-| Use Case | Service to Use | Key Features |
-|----------|---------------|--------------|
-| Simple API calls | `HTTPManagerService` | Observables, retry, polling |
-| Modern reactive UI | `HTTPManagerSignalsService` | Angular Signals |
-| CRUD operations | `HTTPManagerStateService` | Auto state updates |
-| Real-time chat | `HTTPManagerStateService` + WebSocket | Messaging channels |
-| Persistent notifications | `HTTPManagerStateService` + WebSocket | Database-backed |
-| User preferences | `LocalStorageManagerService` | Encryption, expiration |
-| Offline-first | `DatabaseManagerService` | IndexedDB |
-| Large local datasets | `DatabaseManagerService` | Querying, indexing |
+  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
+    });
+
+    this.httpManager.getRequest(options).subscribe();
+  }
+}
+```
+
+#### Advanced Features
 
-## 🏗️ Architecture
-
-For detailed system architecture, data flows, and design patterns, see:
-
-📋 **[Architecture Documentation](architecture/README.md)**
-
-### System Overview
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                         Angular Application                      │
-├─────────────────────────────────────────────────────────────────┤
-│  ┌────────────────┐  ┌────────────────┐  ┌──────────────────┐  │
-│  │   Components   │  │   Components   │  │    Components    │  │
-│  │   (Signals)    │  │  (Observables) │  │  (State Store)   │  │
-│  └───────┬────────┘  └───────┬────────┘  └────────┬─────────┘  │
-│          │                   │                     │             │
-│          ▼                   ▼                     ▼             │
-│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐  │
-│  │HTTPManager   │    │HTTPManager   │    │HTTPManager       │  │
-│  │SignalsService│    │Service       │    │StateService      │  │
-│  └──────┬───────┘    └──────┬───────┘    └────────┬─────────┘  │
-│         │                   │                      │             │
-│         └───────────────────┴──────────────────────┘             │
-│                             │                                    │
-│                             ▼                                    │
-│                    ┌─────────────────┐                          │
-│                    │  HttpClient     │                          │
-│                    │  (Angular)      │                          │
-│                    └────────┬────────┘                          │
-│                             │                                    │
-├─────────────────────────────┼────────────────────────────────────┤
-│                             │                                    │
-│  ┌──────────────────────────┼──────────────────────┐            │
-│  │        Storage Layer                            │            │
-│  ├──────────────────────────┼──────────────────────┤            │
-│  │  ┌────────────────┐      │      ┌─────────────┐│            │
-│  │  │LocalStorage    │      │      │IndexedDB    ││            │
-│  │  │Manager Service │      │      │(Dexie.js)   ││            │
-│  │  └────────────────┘      │      └─────────────┘│            │
-│  └──────────────────────────┼──────────────────────┘            │
-│                             │                                    │
-│  ┌──────────────────────────┼──────────────────────┐            │
-│  │        WebSocket Layer                          │            │
-│  ├──────────────────────────┼──────────────────────┤            │
-│  │  ┌─────────────────────────────────────┐       │            │
-│  │  │   WebsocketService                  │       │            │
-│  │  └─────────────────────────────────────┘       │            │
-│  └─────────────────────────────────────────────────┘            │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## 🔧 Interceptors
-
-The library provides several HTTP interceptors that are automatically configured:
-
-📋 **[Interceptors Documentation](interceptors/README.md)**
-
-### Available Interceptors
-
-- **RequestErrorInterceptor** - Handles 400/500 errors with toast notifications
-- **WithCredentialsInterceptor** - Adds `withCredentials: true` to requests
-- **RequestHeadersInterceptor** - Adds common headers (Content-Type, Accept-Language, Current-Date)
-
-### Manual Configuration
+| 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
-// app.module.ts
-providers: [
-  { provide: HTTP_INTERCEPTORS, useClass: WithCredentialsInterceptor, multi: true },
-  { provide: HTTP_INTERCEPTORS, useClass: RequestHeadersInterceptor, multi: true },
-  { provide: HTTP_INTERCEPTORS, useClass: RequestErrorInterceptor, multi: true }
-]
+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
+});
 ```
 
-## 🎮 Demo Examples
+### 2. Request Manager Signal Service (`HTTPManagerSignalsService`)
 
-Comprehensive demo components showcase all library features:
+**Path:** `request-manager-services/http-manager-signals.service.ts`
 
-📋 **[Demo Examples Documentation](demos/README.md)**
+A modern alternative to `HTTPManagerService` using Angular Signals for state management.
 
-### Available Demos
+**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.
 
-- **HttpRequestServicesDemoComponent** - Main demo component
-- **RequestManagerDemoComponent** - HTTP service demonstrations
-- **RequestManagerStateDemoComponent** - State management examples
-- **RequestManagerWsDemoComponent** - WebSocket functionality
-- **LocalStorageDemoComponent** - Local storage examples
-- **DatabaseDataDemoComponent** - IndexedDB operations
+**Features:**
 
-### Usage
+- **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.
+
+**Usage:**
+Ideal for components using Angular Signals.
+
+```typescript
+export class MyComponent {
+  httpManager = inject(HTTPManagerSignalsService);
+
+  data = this.httpManager.data; // Signal
+  isLoading = this.httpManager.isPending; // Signal
+  error = this.httpManager.error; // Signal
+
+  fetchData() {
+    const options = ApiRequest.adapt({ path: ['users'] });
+    this.httpManager.getRequest(options).subscribe();
+  }
+}
+```
+
+### 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'
+      })
+    );
+  }
+
+  // Wrap CRUD methods for cleaner component usage
+  getUsers() {
+    this.fetchRecords();
+  }
+
+  addUser(user: User) {
+    this.createRecord(user);
+  }
+}
+```
+
+**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'
+  }
+});
+
+// Select a store (returns data)
+settings$ = this.localStorageManager.store$('user-settings');
+
+// Select store settings (returns metadata)
+meta$ = this.localStorageManager.setting$('user-settings');
+
+// Reset all stores
+this.localStorageManager.resetStore();
+```
+
+### 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
+      })
+    );
+  }
+
+  // Update specific part of state
+  updateSetting(value: any) {
+    this.updateData(value);
+  }
+
+  // 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`.
+
+### 7. WebSocket Manager Service (`WebsocketService`)
+
+**Path:** `ws-manager-service/services/websocket.service.ts`
+
+Handles WebSocket connections, channel subscriptions, and messaging. It is used internally by `HTTPManagerStateService` but can be used standalone.
+
+**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.
+
+**Features:**
+
+- **Connection Management:** Handles connecting, disconnecting, and reconnecting.
+- **Authentication:** Supports JWT-based authentication for secure connections.
+- **Channels:** Allows subscribing and unsubscribing to specific channels.
+- **Channel Management:** Create and delete channels dynamically.
+- **Messaging:** Supports sending messages to specific channels, users, or broadcasting to all.
+- **Observables:** Exposes `messages$`, `connectionStatus$`, and `subscribedChannels$` for reactive integration.
+- **Session Persistence:** Automatically generates and persists session IDs for reconnection scenarios.
+
+**Usage:**
+
+```typescript
+wsService = inject(WebsocketService);
+
+// Connect with options
+this.wsService.connect({
+  id: 'my-primary-channel',
+  wsServer: 'wss://api.example.com/ws',
+  user: { ldap: 'jdoe', name: 'John Doe' },
+  channels: ['PUB-notifications', 'PUB-updates']
+}, 'jwt-token');
+
+// Subscribe to additional channels
+this.wsService.subscribeToChannel('PUB-my-channel');
+
+// Unsubscribe from a channel
+this.wsService.unsubscribeFromChannel('PUB-my-channel');
+
+// Listen to messages
+this.wsService.messages$.subscribe(msg => console.log(msg));
+
+// Send message to a channel
+this.wsService.sendChannelMessage('PUB-my-channel', { text: 'Hello!' });
+
+// Track subscribed channels
+this.wsService.subscribedChannels$.subscribe(channels => console.log([...channels]));
+
+// Create/Delete channels
+this.wsService.createChannel('PUB-new-channel');
+this.wsService.deleteChannel('PUB-old-channel');
+
+// Get all available channels
+this.wsService.getAllChannels();
+
+// Get users in a channel
+this.wsService.getUsersInChannel('PUB-my-channel');
+```
+
+#### Channel Naming Conventions
+
+The WebSocket service and state manager use a **channel type system** to organize communication. Channel prefixes are managed automatically by the state service.
+
+##### Channel Types (`ChannelType` Enum)
+
+```typescript
+import { ChannelType, createChannelName } from 'http-request-manager';
+
+export enum ChannelType {
+  STATE = 'SYS',        // Private state synchronization channels
+  MESSAGE = 'MES',      // Messaging/communication channels (persisted notifications)
+  NOTIFICATION = 'PUB'  // Public notification/broadcast channels
+}
+
+// Utility function to create prefixed channel name
+createChannelName(ChannelType.STATE, 'USERS123');  // Returns 'SYS-USERS123'
+createChannelName(ChannelType.MESSAGE, 'alerts');   // Returns 'MES-alerts'
+createChannelName(ChannelType.NOTIFICATION, 'chat'); // Returns 'PUB-chat'
+```
+
+| Channel Type | Prefix | Description | Visibility | Persistence |
+| :--- | :--- | :--- | :--- | :--- |
+| `STATE` | `SYS-` | Private channels for state synchronization (CRUD operations) | Hidden from users | In-memory only |
+| `MESSAGE` | `MES-` | Messaging channels for notifications (persisted to database) | Visible to users | Database persisted |
+| `NOTIFICATION` | `PUB-` | Public channels for real-time messaging/chat | Visible to users | In-memory only |
+
+**Important:** When using `HTTPManagerStateService`, channel prefixes are automatically managed. You only need to provide the base channel name.
+
+**Example:**
+
+```typescript
+// State service automatically adds SYS- prefix for state channels
+// User provides: 'USERS123'
+// State service uses: 'SYS-USERS123'
+
+// For messaging channels, use subscribeToMessageChannel()
+stateService.subscribeToMessageChannel('alerts');  // Uses 'MES-alerts'
+
+// For notification channels, use subscribeToNotificationChannel()
+stateService.subscribeToNotificationChannel('announcements');  // Uses 'PUB-announcements'
+```
+
+#### WebSocket Message Types
+
+| Type | Description | Direction |
+| :--- | :--- | :--- |
+| `subscribe` | Subscribe to a channel | Client → Server |
+| `unsubscribe` | Unsubscribe from a channel | Client → Server |
+| `message` | Send message to channel subscribers | Client → Server |
+| `broadcast` | Broadcast to all connected clients | Client → Server |
+| `userMessage` | Send message to specific user | Client → Server |
+| `createChannel` | Create a new channel | Client → Server |
+| `deleteChannel` | Delete an existing channel | Client → Server |
+| `getChannels` | Request list of all channels | Client → Server |
+| `getUsers` | Get users in a channel | Client → Server |
+| `channelsList` | List of available channels | Server → Client |
+| `subscribed` | Subscription confirmation | Server → Client |
+| `unsubscribed` | Unsubscription confirmation | Server → Client |
+| `incomingMessage` | Message received in a channel | Server → Client |
+
+#### 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()
+    );
+  }
+}
+```
+
+---
+
+## Real-Time Features
+
+The `http-request-manager` library provides two distinct real-time communication features:
+
+1. **Messaging (PUB- channels)** - Real-time chat/messaging between users
+2. **Notifications (MES- channels)** - Persistent notifications stored in database
+
+Both features integrate seamlessly with `HTTPManagerStateService` and automatically manage channel prefixes.
+
+### Messaging Feature (PUB- Channels)
+
+**Purpose:** Real-time messaging/chat functionality for communication between users.
+
+**Characteristics:**
+
+- Messages are broadcast in real-time to subscribed users
+- Messages are stored in-memory only (not persisted to database)
+- Uses `PUB-` prefix (automatically added)
+- Ideal for chat applications, live collaboration, etc.
+
+#### Messaging Observables
+
+| Observable | Type | Description |
+| :--- | :--- | :--- |
+| `channels$` | `Observable<string[]>` | List of all available channels |
+| `communicationMessages$` | `Observable<any[]>` | All received messages |
+| `latestCommunicationMessages$` | `Observable<any>` | Most recent message received |
+| `connectionStatus$` | `Observable<boolean>` | WebSocket connection status |
+| `user$` | `Observable<WSUser>` | Current user information |
+
+#### Messaging Methods
+
+```typescript
+// Create a new messaging channel
+stateService.createChannel('general-chat');  // Creates PUB-general-chat
+
+// Subscribe to a channel to receive messages
+stateService.subscribeToChannel('general-chat');  // Subscribes to PUB-general-chat
+
+// Unsubscribe from a channel
+stateService.unsubscribeFromChannel('general-chat');
+
+// Get all available channels
+stateService.getAllChannels();
+
+// Send a message to specific channels
+stateService.wsMessaging(
+  ChannelMessage.adapt({
+    sessionId: currentUser,
+    content: { message: 'Hello everyone!' }
+  }),
+  ['general-chat', 'team-updates']  // Channels (PUB- prefix added automatically)
+);
+```
+
+#### Demo Component: `WsMessagingComponent`
+
+The library includes a demo component showcasing messaging functionality:
 
 ```html
-<app-http-request-services-demo
+<app-ws-messaging
   [server]="'http://localhost:8080'"
   [wsServer]="'ws://localhost:8080'"
   [jwtToken]="'your-jwt-token'"
-  [adapter]="myAdapterFunction"
-  [mapper]="myMapperFunction">
-</app-http-request-services-demo>
+  [user]="{ ldap: 'jdoe', name: 'John Doe', email: 'jdoe@example.com' }">
+</app-ws-messaging>
 ```
 
-## 📖 Migration Guide
+**Features demonstrated:**
 
-### From HttpClient to HTTPManagerService
+- Create public channels
+- Subscribe/unsubscribe to channels
+- Send messages to multiple channels
+- View real-time message stream
+- Toast notifications for incoming messages
+
+---
+
+### Notifications Feature (MES- Channels)
+
+**Purpose:** Persistent notifications that are stored in the database and can be retrieved with date filters.
+
+**Characteristics:**
+
+- Notifications are persisted to the server database
+- Supports date-range queries (startEpoch, endEpoch)
+- Uses `MES-` prefix (automatically added)
+- Retrieves historical notifications on subscription
+- Ideal for announcements, alerts, audit logs, etc.
+
+#### Notification Observables
+
+| Observable | Type | Description |
+| :--- | :--- | :--- |
+| `notificationChannels$` | `Observable<string[]>` | In-memory notification channels from server |
+| `todaysNotificationChannels$` | `Observable<string[]>` | Channels with notifications posted today (from DB) |
+| `notificationMessages$` | `Observable<any[]>` | All notification messages |
+| `latestNotification$` | `Observable<any>` | Most recent notification received |
+
+#### Notification Methods
 
-**Before:**
 ```typescript
-http.get('api/users').subscribe(users => {
-  this.users = users;
-  this.loading = false;
+// Create a notification channel
+stateService.createNotificationChannel('alerts');  // Creates MES-alerts
+
+// Get all notification channels (in-memory)
+stateService.getNotificationChannels();
+
+// Get today's notification channels (from database)
+stateService.getTodaysNotificationChannels();
+
+// Define and load previous day's notification channels
+// This retrieves channels from the previous day's database records,
+// creates them in memory if needed, and broadcasts the updated list
+stateService.definePreviousNotificationChannels();
+
+// Subscribe to notifications with optional date filter
+stateService.subscribeToNotificationChannel('alerts', {
+  startEpoch: Math.floor(Date.now() / 1000) - 86400,  // Last 24 hours
+  endEpoch: Math.floor(Date.now() / 1000)
+});
+
+// Unsubscribe from notifications
+stateService.unsubscribeFromNotificationChannel('alerts');
+
+// Send a notification (persisted to database)
+stateService.sendNotification('alerts', {
+  title: 'System Alert',
+  message: 'Scheduled maintenance at midnight',
+  priority: 'high'
 });
 ```
 
-**After:**
+#### Notification Message Structure
+
 ```typescript
-httpManager.getRequest(
-  ApiRequest.adapt({ path: ['users'] })
-).subscribe();
+interface NotificationMessage {
+  id: number;
+  channel: string;      // e.g., 'MES-alerts'
+  created: number;      // epoch seconds
+  user_name: string;    // sender's name
+  sessionId: any;       // sender's session info
+  content: any;         // notification payload
+}
+```
+
+#### Demo Component: `WsNotificationsComponent`
 
-data$ = this.httpManager.data$;
-isLoading$ = this.httpManager.isPending$;
+The library includes a demo component showcasing notification functionality:
+
+```html
+<app-ws-notifications
+  [server]="'http://localhost:8080'"
+  [wsServer]="'ws://localhost:8080'"
+  [jwtToken]="'your-jwt-token'"
+  [user]="{ ldap: 'jdoe', name: 'John Doe', email: 'jdoe@example.com' }">
+</app-ws-notifications>
 ```
 
-### From Manual State to HTTPManagerStateService
+**Features demonstrated:**
+
+- Create notification channels
+- View today's notification channels (from database)
+- Define previous day's channels (loads channels from previous day's data)
+- Subscribe with date range filters
+- Connect/disconnect from channels
+- Send notifications (persisted)
+- View historical notifications in a table
+
+---
+
+### Creating a Custom State Service with Messaging & Notifications
+
+Here's a complete example of a state service that utilizes all real-time features:
 
-**Before:**
 ```typescript
-users: User[] = [];
-loading = false;
-
-loadUsers() {
-  this.loading = true;
-  this.http.get('api/users').subscribe(users => {
-    this.users = users;
-    this.loading = false;
-  });
+import { Injectable } from '@angular/core';
+import { HTTPManagerStateService, ChannelType, createChannelName } from 'http-request-manager';
+import { ApiRequest, DataType, DatabaseStorage } from 'http-request-manager';
+
+export interface User {
+  id: number;
+  name: string;
+  email: string;
 }
 
-addUser(user: User) {
-  this.http.post('api/users', user).subscribe(newUser => {
-    this.users = [...this.users, newUser];
-  });
+@Injectable({
+  providedIn: 'root'
+})
+export class UserStateService extends HTTPManagerStateService<User> {
+
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'http://localhost:8080',
+        path: ['api', 'users'],
+        adapter: (data: any) => data as User,
+        ws: {
+          id: 'USERS123',  // Base name - automatically becomes SYS-USERS123
+          wsServer: 'ws://localhost:8080',
+          jwtToken: '',
+          retry: { times: 3, delay: 5 }
+        }
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table: 'users-cache', expiresIn: '1d' })
+    );
+  }
+
+  // Initialize connection with user info
+  initializeConnection(wsServer: string, jwtToken: string, user: any) {
+    this.setApiRequestOptions(
+      ApiRequest.adapt({
+        ...this.ApiRequestOptions,
+        ws: {
+          ...this.ApiRequestOptions.ws,
+          wsServer,
+          jwtToken,
+          user
+        }
+      })
+    );
+  }
+
+  // === MESSAGING (PUB- channels) ===
+
+  createChatRoom(roomName: string) {
+    this.createChannel(roomName);  // Creates PUB-{roomName}
+  }
+
+  joinChatRoom(roomName: string) {
+    this.subscribeToChannel(roomName);
+  }
+
+  leaveChatRoom(roomName: string) {
+    this.unsubscribeFromChannel(roomName);
+  }
+
+  sendChatMessage(content: string, rooms: string[]) {
+    this.wsMessaging(
+      { content: { message: content } },
+      rooms
+    );
+  }
+
+  // === NOTIFICATIONS (MES- channels) ===
+
+  createNotificationStream(streamName: string) {
+    this.createNotificationChannel(streamName);  // Creates MES-{streamName}
+  }
+
+  subscribeToAlerts(streamName: string, lastHours: number = 24) {
+    const now = Math.floor(Date.now() / 1000);
+    const startEpoch = now - (lastHours * 3600);
+
+    this.subscribeToNotificationChannel(streamName, {
+      startEpoch,
+      endEpoch: now
+    });
+  }
+
+  sendAlert(streamName: string, alert: { title: string; message: string; priority: string }) {
+    this.sendNotification(streamName, alert);
+  }
 }
 ```
 
-**After:**
+**Usage in Component:**
+
 ```typescript
-@Injectable()
-export class UsersStore extends HTTPManagerStateService<User> {
-  constructor() {
-    super(ApiRequest.adapt({ path: ['users'] }), DataType.ARRAY);
+@Component({
+  selector: 'app-dashboard',
+  template: `
+    <div *ngIf="connectionStatus$ | async">
+      <!-- Chat Messages -->
+      <div *ngFor="let msg of chatMessages$ | async">
+        {{ msg.content.message }}
+      </div>
+
+      <!-- Notifications -->
+      <div *ngFor="let notification of notifications$ | async">
+        {{ notification.content.title }}: {{ notification.content.message }}
+      </div>
+    </div>
+  `
+})
+export class DashboardComponent implements OnInit {
+  userState = inject(UserStateService);
+
+  connectionStatus$ = this.userState.connectionStatus$;
+  chatMessages$ = this.userState.communicationMessages$;
+  notifications$ = this.userState.notificationMessages$;
+
+  ngOnInit() {
+    // Initialize WebSocket connection
+    this.userState.initializeConnection(
+      'ws://localhost:8080',
+      'jwt-token',
+      { ldap: 'jdoe', name: 'John Doe' }
+    );
+
+    // Join a chat room
+    this.userState.joinChatRoom('general');
+
+    // Subscribe to alerts from last 24 hours
+    this.userState.subscribeToAlerts('system-alerts', 24);
+  }
+
+  sendMessage(text: string) {
+    this.userState.sendChatMessage(text, ['general']);
+  }
+
+  sendAlert() {
+    this.userState.sendAlert('system-alerts', {
+      title: 'Update Available',
+      message: 'A new version is available',
+      priority: 'medium'
+    });
   }
-  
-  loadUsers() { this.fetchRecords(); }
-  addUser(user: User) { this.createRecord(user); }
 }
+```
 
-// Component
-data$ = this.usersStore.data$;
-isLoading$ = this.usersStore.isPending$;
+---
+
+### 8. Database Manager Service (`DatabaseManagerService`)
+
+**Path:** `database-manager-service/database.manager.service.ts`
+
+A wrapper service for Dexie.js to manage IndexedDB interactions using RxJS Observables.
+
+**What it does:**
+
+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.
+
+**Features:**
+
+- **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.
+
+**Usage:**
+
+```typescript
+dbManager = inject(DatabaseManagerService);
+
+// 1. Initialize Table
+const tableDef = TableSchemaDef.adapt({
+  table: 'users',
+  schema: '++id, name, age' // Dexie.js schema syntax
+});
+
+this.dbManager.createDatabaseTable(tableDef).subscribe(() => {
+  console.log('Table initialized');
+});
+
+// 2. CRUD Operations
+// Create
+this.dbManager.createTableRecord('users', { name: 'John', age: 30 }).subscribe();
+
+// Read
+this.dbManager.getTableRecords('users').subscribe(users => console.log(users));
+this.dbManager.getTableRecord('users', 1).subscribe(user => console.log(user));
+
+// Update
+this.dbManager.updateTableRecord('users', { id: 1, name: 'John Doe', age: 31 }).subscribe();
+
+// Delete
+this.dbManager.deleteTableRecord('users', 1).subscribe();
+
+// 3. Bulk Operations
+const users = [{ name: 'Alice', age: 25 }, { name: 'Bob', age: 28 }];
+this.dbManager.createTableRecords('users', users).subscribe();
+
+// 4. Querying
+this.dbManager.findTableRecords('users', 'age', 25).subscribe(results => console.log(results));
+
+// 5. Metadata
+this.dbManager.hasDatabaseTable('users').subscribe(exists => console.log(exists));
 ```
 
-## 📋 API Reference
+#### Database Storage Configuration (`DatabaseStorage`)
 
-### Core Models
+When using `HTTPManagerStateService`, you can configure local database caching using `DatabaseStorage.adapt()`.
 
-- **ApiRequest** - HTTP request configuration
-- **RetryOptions** - Retry behavior settings  
-- **DataType** - Data structure type (ARRAY, OBJECT)
-- **DatabaseStorage** - IndexedDB configuration
-- **SettingOptions** - Storage settings
-- **WSOptions** - WebSocket configuration
+##### Options
 
-### Enums
+| 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). | `''` |
 
-- **StreamType** - Streaming response types
-- **StorageType** - Storage scope (GLOBAL, SESSION)
-- **CommunicationType** - WebSocket message types
+##### Database Storage Example
 
-## 🤝 Contributing
+```typescript
+import { DatabaseStorage } from 'http-request-manager';
 
-This library is designed to be enterprise-ready and production-safe. All features include comprehensive error handling, TypeScript support, and extensive configuration options.
+const dbConfig = DatabaseStorage.adapt({
+  table: 'my-feature-cache',
+  expiresIn: '6h' // Cache expires in 6 hours
+});
+```
+
+### 9. Utils (`UtilsService`)
+
+**Path:** `utils/utils.service.ts`
+
+Provides utility functions for common tasks.
+
+**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.
+
+**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.
+
+**Usage:**
 
-## 📄 License
+```typescript
+utils = inject(UtilsService);
+
+// Check expiration
+const isExpired = this.utils.hasExpired(expiryTimestamp);
 
-This project is part of the Angular application library suite.
+// Convert JSON
+const json = this.utils.stringToJSON(jsonString);
+
+// Calculate Expiry
+const expiryEpoch = this.utils.expires('1d'); // Returns epoch for 1 day from now
+```
 
 ---
 
-**Need help?** Check out the detailed documentation for each service, explore the demo examples, or review the architecture documentation for implementation guidance.
+## Available Interceptors
+
+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.
+
+```typescript
+providers: [
+  { provide: HTTP_INTERCEPTORS, useClass: WithCredentialsInterceptor, multi: true },
+  { provide: HTTP_INTERCEPTORS, useClass: RequestHeadersInterceptor, multi: true },
+  { provide: HTTP_INTERCEPTORS, useClass: RequestErrorInterceptor, multi: true }
+],
+```
+
+Or you can use all intercepts above by importing the `HttpRequestManagerModule` in your `AppModule`
+
+- **RequestErrorInterceptor**
+
+This interceptor handles errors of type 400 and 500. This interceptor is applicable when you need to display UI for the user to indicate a server or request error has occurred. The Status and Error Text is displayed in a `toast-message` modal.
+
+- **WithCredentialsInterceptor**
+
+  Adds to your request header
+
+  ```json
+  { credentials: true }
+  ```
+
+- **RequestHeadersInterceptor**
+
+  Adds to your request - current local `language` (i18n) selection and `current date` to every request
+
+  ```json
+  {
+    'Content-Type': 'application/json',
+    'Accept-Language': this.language || 'en-CA',
+    'Current-Date': this.currentDate
+  }
+  ```