npm - http-request-manager - Versions diffs - 18.15.34 → 18.16.1 - Mend

http-request-manager 18.15.34 → 18.16.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (300) hide show

package/src/docs/COMPLETE_API_REFERENCE.md DELETED Viewed

@@ -1,1037 +0,0 @@
-# HTTP Request Manager - Complete API Reference
-A comprehensive guide to all services, methods, and features available in the HTTP Request Manager library.
-## Table of Contents
-1. [HTTP Services](#http-services)
-2. [State Management Services](#state-management-services)
-3. [WebSocket Services](#websocket-services)
-4. [Storage Services](#storage-services)
-5. [Database Services](#database-services)
-6. [Utility Services](#utility-services)
-7. [Interceptors](#interceptors)
-8. [Models & Configuration](#models--configuration)
----
-## HTTP Services
-### HTTPManagerService
-**Location:** `services/request-manager-services/http-manager.service.ts`
-**Description:** Core HTTP client service with Observable-based state management.
-**Features:**
-- HTTP CRUD operations (GET, POST, PUT, DELETE)
-- Loading states (`isPending$`, `error$`, `data$`, `countdown$`)
-- Configurable retry logic
-- Polling with countdown timers
-- Data adapters and mappers
-- Streaming response support (NDJSON, SSE)
-- File download with progress tracking
-**Observable Properties:**
-```typescript
-data$: Observable<any>              // Response data
-isPending$: Observable<boolean>     // Loading state
-error$: Observable<any>             // Error state
-countdown$: Observable<number>      // Polling countdown
-```
-**Methods:**
-#### HTTP Request Methods
-```typescript
-getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>
-postRequest<T>(data: T, options: ApiRequest, params?: any[]): Observable<T>
-putRequest<T>(data: T, options: ApiRequest, params?: any[]): Observable<T>
-deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>
-downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>
-uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]): Observable<T>
-```
-#### WebSocket Methods (delegated to WebSocketManagerService)
-```typescript
-connect(options: WSOptions, jwtToken: string): void
-disconnect(): void
-subscribeToChannel(channel: string, userData?: any): void
-subscribeToChannels(channels: string[], userData?: any): void
-unsubscribeFromChannel(channel: string): void
-getSubscribedChannels(): Set<string>
-sendBroadcast(content: any): void
-sendMessageInChannel(channel: string, content: any): void
-sendChannelMessage(channel: string, content: any): void
-sendChannelMessageToChannels(channels: string[], content: any): void
-sendMessageToUser(user: string, content: any): void
-getAllChannels(): void
-createChannel(channel: string): void
-deleteChannel(channel: string): void
-```
-**Usage Example:**
-```typescript
-import { HTTPManagerService, ApiRequest } from 'http-request-manager';
-@Component({})
-export class UsersComponent {
-  httpManager = inject(HTTPManagerService);
-  data$ = this.httpManager.data$;
-  isLoading$ = this.httpManager.isPending$;
-  ngOnInit() {
-    this.httpManager.getRequest(
-      ApiRequest.adapt({
-        path: ['users'],
-        retry: { times: 3, delay: 1 }
-      })
-    ).subscribe();
-  }
-}
-```
----
-### HTTPManagerSignalsService
-**Location:** `services/request-manager-services/http-manager-signals.service.ts`
-**Description:** Signal-based HTTP service with the same features as HTTPManagerService.
-**Signal Properties:**
-```typescript
-data: Signal<any>              // Response data
-isPending: Signal<boolean>     // Loading state
-error: Signal<any>             // Error state
-countdown: Signal<number>      // Polling countdown
-```
-**Methods:** Same as HTTPManagerService
-**Usage Example:**
-```typescript
-import { HTTPManagerSignalsService, ApiRequest } from 'http-request-manager';
-@Component({
-  template: `
-    <div *ngIf="isLoading()">Loading...</div>
-    <div *ngFor="let user of data()">{{ user.name }}</div>
-  `
-})
-export class UsersComponent {
-  httpManager = inject(HTTPManagerSignalsService);
-  data = this.httpManager.data;
-  isLoading = this.httpManager.isPending;
-  ngOnInit() {
-    this.httpManager.getRequest(
-      ApiRequest.adapt({ path: ['users'] })
-    ).subscribe();
-  }
-}
-```
----
-## State Management Services
-### HTTPManagerStateService
-**Location:** `services/request-manager-state-service/http-manager-state.store.ts`
-**Description:** Comprehensive state management service combining HTTP requests, WebSocket real-time updates, and IndexedDB persistence. Extends NgRx ComponentStore.
-**Extends:** `ComponentStore<APIStateManagerData<T>>`
-**Features:**
-- All HTTPManagerService features
-- ComponentStore-based state management
-- Automatic CRUD state updates
-- WebSocket integration with channel prefixes
-- IndexedDB caching with expiration
-- Pagination support
-- Real-time synchronization
-- Database flush capability
-**Observable Properties:**
-```typescript
-// From ComponentStore
-data$: Observable<T[]>                    // Array data
-page$: Observable<number>                 // Current page
-totalPages$: Observable<number>           // Total pages
-percentage$: Observable<number>           // Download percentage
-// WebSocket
-messages$: Observable<any>                // All WS messages
-userListByChannel$: Observable<Map<string, any[]>>
-userList$: Observable<any[]>              // Unique users
-user$: Observable<WSUser|null>            // Current user
-channels$: Observable<string[]|null>      // Subscribed channels
-// Notifications
-notificationChannels$: Observable<string[]>        // In-memory channels
-todaysNotificationChannels$: Observable<string[]>  // DB channels
-notificationMessages$: Observable<any[]>           // Notification list
-latestNotification$: Observable<any>               // Latest notification
-// Communication
-communicationMessages$: Observable<any[]>          // Channel messages
-latestCommunicationMessages$: Observable<any|null>
-userAction$: Observable<any|null>                  // WS-triggered actions
-// Connection
-connectionStatus$: Observable<boolean>             // WS connection
-wsRetryAttempts$: Observable<number>               // Retry count
-wsNextRetry$: Observable<number>                   // Next retry countdown
-```
-**Methods:**
-#### State Management
-```typescript
-initializeState(data: any): void
-clearRecords(): void
-```
-#### CRUD Operations
-```typescript
-fetchRecords(options?: RequestOptions): Effect
-fetchRecord(options: RequestOptions, method: string): Effect
-createRecord(data: any|null, options?: RequestOptions): Effect
-updateRecord(data: any|null, options?: RequestOptions): Effect
-deleteRecord(options?: RequestOptions): Effect
-```
-**RequestOptions for fetchRecords/fetchStream:**
-| Property | Type | Default | Description |
-|----------|------|---------|-------------|
-| `path` | `any[]` | `[]` | URL path segments |
-| `headers` | `any` | `{}` | Custom HTTP headers |
-| `forceRefresh` | `boolean` | `undefined` | Bypass query tracking and always make the API request |
-| `ignoreQueryParams` | `string[]` | `[]` | Query parameter keys to exclude from request-change tracking |
-| `queryParamsExpiresIn` | `string \| number` | `undefined` | Expiry duration for tracked query values (e.g., `'10s'`, `'5mn'`, `'1h'`) |
-| `watchParams` | `string[]` | `undefined` | Specific query keys to watch for change detection (variation mode) |
-| `watchExpiresAt` | `number` | `undefined` | Epoch timestamp when tracked values expire |
-**Scope and behavior:**
-- Database enabled (`DatabaseStorage` configured): tracker is active and can prevent repeated identical API calls until expiry resets tracked values.
-- Database disabled: tracker is not enabled; requests go straight to API.
-- `forceRefresh: true` bypasses tracking and always makes the API request.
-#### Streaming
-```typescript
-createStream(data: any|null, options?: RequestOptions): Effect
-fetchStream(options?: RequestOptions): Effect
-```
-#### Database Operations
-```typescript
-clearDatabase(): void
-```
-**Clear Database Example:**
-```typescript
-// Simple call - subscription handled internally
-myStateService.clearDatabase();
-// This will:
-// 1. Clear all records from IndexedDB table
-// 2. Clear in-memory state (set to empty array/object)
-// 3. Log success/error to console
-// 4. NOT re-fetch from API
-// 5. NOT clear localStorage metadata
-```
-#### WebSocket Communication
-```typescript
-wsCommunication(method: string, path?: string|number[]): void
-wsMessaging(message: ChannelMessage, channels?: string[]): void
-```
-#### Channel Management
-```typescript
-subscribeToChannel(channel: string): void
-subscribeToChannels(channels: string[]): void
-unsubscribeFromChannel(channel: string): void
-getSubscribedChannels(): Set<string>
-createChannel(channel: string): void
-deleteChannel(channel: string): void
-getAllChannels(): void
-getUsersInChannel(channel: string): void
-```
-#### Message Channels (PUB- prefix)
-```typescript
-subscribeToMessageChannel(channel: string): void
-unsubscribeFromMessageChannel(channel: string): void
-```
-#### Notification Channels (MES- prefix)
-```typescript
-createNotificationChannel(channel: string): void
-getNotificationChannels(): void
-getTodaysNotificationChannels(): void
-subscribeToNotificationChannel(channel: string, options?: { startEpoch?: number; endEpoch?: number }, user?: any): void
-unsubscribeFromNotificationChannel(channel: string): void
-sendNotification(channel: string, content: any): void
-```
-**Usage Example:**
-```typescript
-import { HTTPManagerStateService, ApiRequest, DataType, DatabaseStorage } from 'http-request-manager';
-@Injectable()
-export class UsersStateService extends HTTPManagerStateService<User> {
-  constructor() {
-    super(
-      ApiRequest.adapt({
-        server: 'https://api.example.com',
-        path: ['users'],
-        adapter: User.adapt
-      }),
-      DataType.ARRAY,
-      DatabaseStorage.adapt({
-        table: 'users',
-        expiresIn: '1h'
-      })
-    );
-  }
-}
-// Component
-@Component({})
-export class UsersComponent {
-  usersStore = inject(UsersStateService);
-  data$ = this.usersStore.data$;
-  ngOnInit() {
-    this.usersStore.fetchRecords();
-  }
-  onClearCache() {
-    this.usersStore.clearDatabase();
-  }
-}
-```
----
-### StoreStateManagerService
-**Location:** `services/store-state-manager-service/store-state-manager.service.ts`
-**Description:** LocalStorage persistence with ComponentStore integration.
-**Extends:** `ComponentStore<T>`
-**Features:**
-- Automatic state synchronization with LocalStorage
-- Configurable model-based state
-- Reactive updates via localStorage changes
-**Methods:**
-```typescript
-init(options?: StateStorageOptions): void
-restoreState(): Subscription
-updateState(state: any): void
-```
-**Usage Example:**
-```typescript
-import { StoreStateManagerService, StateStorageOptions } from 'http-request-manager';
-@Injectable()
-export class AppStore extends StoreStateManagerService<AppState> {
-  constructor() {
-    super(StateStorageOptions.adapt({
-      store: 'app-state',
-      model: () => ({
-        theme: 'light',
-        language: 'en',
-        notifications: true
-      }),
-      options: SettingOptions.adapt({
-        storage: StorageType.GLOBAL,
-        encrypted: false,
-        expiresIn: '30d'
-      })
-    }));
-  }
-}
-```
----
-## WebSocket Services
-### WebSocketManagerService
-**Location:** `services/ws-manager-service/websocket-service/websocket-manager.service.ts`
-**Description:** Singleton WebSocket connection manager ensuring only ONE connection across ALL instances.
-**Features:**
-- Single static connection (shared across all instances)
-- Connection lifecycle management
-- Channel subscription tracking
-- Session ID management (UUID per browser session)
-- JWT authentication support
-- Automatic reconnection handling
-- Message replay support (lastSeenId)
-**Static Properties:**
-```typescript
-private static socket: WebSocket | null
-private static isConnecting: boolean
-private static connectionInitialized: boolean
-private static lastOptions: WSOptions | null
-```
-**Observable Properties:**
-```typescript
-messages$: Observable<any>              // All messages
-connectionStatus$: Observable<boolean>  // Connection state
-subscribedChannels$: Observable<Set<string>>
-onReconnect$: Observable<void>          // Reconnect events
-```
-**Methods:**
-#### Connection Management
-```typescript
-connect(options: WSOptions, jwtToken: string): void
-disconnect(): void
-```
-#### Subscription Management
-```typescript
-subscribeToChannel(channelName: string): void
-subscribeToChannels(channelNames: string[]): void
-unsubscribeFromChannel(channelName: string): void
-getSubscribedChannels(): Set<string>
-addSubscribedChannel(channelName: string): void
-sendSubscribe(channelName: string, user: any): void
-sendSubscribeWithLastSeen(channelName: string, user: any, lastSeenId: number): void
-```
-#### Messaging
-```typescript
-sendBroadcast(content: any): void
-sendMessageInChannel(channel: string, content: any): void
-sendChannelMessage(channel: string, content: any): void
-sendChannelMessageToChannels(channels: string[], content: any): void
-sendMessageToUser(user: string, content: any): void
-```
-#### Channel Management
-```typescript
-createChannel(channel: string): void
-deleteChannel(channel: string): void
-getAllChannels(): void
-getUsersInChannel(channel: string): void
-```
-**Usage Example:**
-```typescript
-import { WebSocketManagerService, WSOptions } from 'http-request-manager';
-@Component({})
-export class ChatComponent {
-  wsManager = inject(WebSocketManagerService);
-  ngOnInit() {
-    // Connection is singleton - only first call connects
-    this.wsManager.connect(
-      WSOptions.adapt({
-        wsServer: 'wss://ws.example.com',
-        id: 'chat-room',
-        user: { id: 'user123', name: 'John' }
-      }),
-      'jwt-token'
-    );
-    // Listen to messages
-    this.wsManager.messages$.subscribe(message => {
-      console.log('Received:', message);
-    });
-    // Subscribe to channel
-    this.wsManager.subscribeToChannel('chat-room');
-  }
-  sendMessage(content: any) {
-    this.wsManager.sendChannelMessage('chat-room', content);
-  }
-}
-```
----
-### MessageTrackerService
-**Location:** `services/ws-manager-service/message-tracker.service.ts`
-**Description:** Message history tracking and re-subscription management.
-**Features:**
-- Message history with persistence
-- Last-seen message ID tracking
-- Automatic re-subscription on reconnect
-- Notification channel management
-- Historical message retrieval
-**Methods:**
-```typescript
-subscribeToChannel(channel: string, userData?: any): void
-getNotificationChannels(): void
-getTodaysNotificationChannels(): void
-subscribeToNotificationChannel(channel: string, options?: any, user?: any): void
-unsubscribeFromNotificationChannel(channel: string): void
-sendNotification(channel: string, content: any): void
-createNotificationChannel(channel: string): void
-```
----
-## Storage Services
-### LocalStorageManagerService
-**Location:** `services/local-storage-manager-service/local-storage-manager.service.ts`
-**Description:** LocalStorage and SessionStorage management with encryption and expiration.
-**Extends:** `ComponentStore<State>`
-**Features:**
-- LocalStorage (GLOBAL) and SessionStorage (SESSION) support
-- AES encryption for sensitive data
-- Automatic expiration cleanup
-- Reactive store$ observables
-- Metadata tracking (settings, expires)
-**Observable Properties:**
-```typescript
-stores$: Observable<StorageOption[]>      // All store metadata
-store$(name: string): Observable<any>     // Store data observable
-setting$(name: string): Observable<any>   // Store settings observable
-```
-**Signal Methods:**
-```typescript
-signal<T>(key: string, defaultValue: T): WritableSignal<T>
-```
-**Methods:**
-#### Store Management
-```typescript
-createStore(options: StoreOptions): void
-updateStore(options: StoreOptions): void
-deleteStore(options: { name: string }): void
-resetStore(): void
-```
-#### Item Operations
-```typescript
-setItem(key: string, value: any, options?: SettingOptions): void
-getItem(key: string): any
-removeItem(key: string): void
-```
-#### Observable Methods
-```typescript
-store$(name: string): Observable<any>
-setting$(name: string): Observable<any>
-stores$: Observable<StorageOption[]>
-```
-**Usage Example:**
-```typescript
-import { LocalStorageManagerService, SettingOptions, StorageType } from 'http-request-manager';
-@Component({})
-export class SettingsComponent {
-  storage = inject(LocalStorageManagerService);
-  // Signal-based access
-  theme = this.storage.signal('theme', 'light');
-  language = this.storage.signal('language', 'en');
-  // Observable-based access
-  settings$ = this.storage.store$('user-preferences');
-  // Manual operations
-  saveSettings() {
-    this.storage.setItem('user-preferences', {
-      theme: this.theme(),
-      language: this.language()
-    }, SettingOptions.adapt({
-      storage: StorageType.GLOBAL,
-      encrypted: false,
-      expiresIn: '30d'
-    }));
-  }
-}
-```
----
-### LocalStorageSignalsManagerService
-**Location:** `services/local-storage-manager-service/local-storage-signals-manager.service.ts`
-**Description:** Signal-optimized version of LocalStorageManagerService.
-**Features:** Same as LocalStorageManagerService but with Signal-first API
----
-## Database Services
-### DatabaseManagerService
-**Location:** `services/database-manager-service/database.manager.service.ts`
-**Description:** IndexedDB wrapper using Dexie.js with Observable API.
-**Extends:** `DbService` (Dexie.js wrapper)
-**Features:**
-- IndexedDB table management
-- Observable-based CRUD operations
-- Bulk operations
-- Query support with filtering
-- Schema inspection
-**Methods:**
-#### Table Management
-```typescript
-getDatabaseTables(): Observable<string[]>
-databaseExists(): Observable<boolean>
-hasDatabaseTable(tableName: string): Observable<boolean>
-getDatabaseTable(tableName: string): Observable<any>
-getDatabaseTableSchema(tableName: string): Observable<string[]>
-createDatabaseTable(tableDef: TableSchemaDef): Observable<void>
-updateDatabaseTableSchema(tableDef: TableSchemaDef): Observable<any>
-```
-#### CRUD Operations
-```typescript
-// Read
-getTableRecords(table: string): Observable<any[]>
-getTableRecord(table: string, id: number): Observable<any>
-findTableRecords(table: string, column: string, value: any): Observable<any[]>
-findTableRecord(table: string, column: string, value: any): Observable<any>
-// Create
-createTableRecord(table: string, record: any): Observable<any>
-createTableRecords(table: string, records: any[]): Observable<any[]>
-// Update
-updateTableRecord(table: string, record: any): Observable<any>
-updateTableRecords(table: string, records: any[]): Observable<any[]>
-// Delete
-deleteTableRecord(table: string, id: number): Observable<void>
-deleteTableRecords(table: string, ids: number[]): Observable<void>
-deleteTableRecordByColumn(table: string, column: string, value: any): Observable<void>
-// Clear
-clearTable(table: string): Observable<any>
-```
-**Clear Table Example:**
-```typescript
-import { DatabaseManagerService, TableSchemaDef } from 'http-request-manager';
-@Component({})
-export class DatabaseComponent {
-  dbManager = inject(DatabaseManagerService);
-  initializeTable() {
-    const tableDef = TableSchemaDef.adapt({
-      table: 'users',
-      schema: '++id, name, email, age, createdAt'
-    });
-    this.dbManager.createDatabaseTable(tableDef).subscribe();
-  }
-  addSampleData() {
-    const users = [
-      { name: 'John', email: 'john@example.com', age: 30 },
-      { name: 'Jane', email: 'jane@example.com', age: 25 }
-    ];
-    this.dbManager.createTableRecords('users', users).subscribe();
-  }
-  loadData() {
-    this.dbManager.getTableRecords('users').subscribe(users => {
-      console.log('Users:', users);
-    });
-  }
-  clearData() {
-    this.dbManager.clearTable('users').subscribe(() => {
-      console.log('Table cleared');
-    });
-  }
-}
-```
----
-## Utility Services
-### UtilsService
-**Location:** `services/utils/utils.service.ts`
-**Description:** Collection of utility functions for common tasks.
-**Methods:**
-#### JSON Handling
-```typescript
-stringToJSON(str: string): any
-JSONToString(obj: any): string
-```
-#### Type Checking
-```typescript
-isString(value: any): boolean
-isObject(value: any): boolean
-isJson(str: string): boolean
-```
-#### Expiration Management
-```typescript
-expires(duration: string): number          // Convert '1h', '30mn' to epoch
-hasExpired(epoch: number): boolean         // Check if timestamp expired
-timeRemaining(epoch: number): string       // Time until expiration
-```
-#### Conversions
-```typescript
-base32ToHex(base32: string): string
-binaryToHex(binary: string): string
-```
-#### Object Operations
-```typescript
-deepCompare(obj1: any, obj2: any): boolean
-getProperty(obj: any, path: string): any
-```
-**Usage Example:**
-```typescript
-import { UtilsService } from 'http-request-manager';
-utils = inject(UtilsService);
-// Expiration
-const expires = this.utils.expires('1h');  // Epoch timestamp
-const hasExpired = this.utils.hasExpired(expires);
-// JSON
-const obj = this.utils.stringToJSON('{"name": "John"}');
-const str = this.utils.JSONToString({ name: 'John' });
-// Type checking
-if (this.utils.isString(value)) { ... }
-```
----
-### ObjectMergerService
-**Location:** `services/utils/object-merger.service.ts`
-**Description:** Deep merge utility for objects.
-**Methods:**
-```typescript
-merge(target: any, source: any): any
-```
----
-### SymmetricalEncryptionService
-**Location:** `services/utils/encryption/symmetrical-encryption.service.ts`
-**Description:** AES encryption/decryption utility.
-**Methods:**
-```typescript
-encrypt(data: any, key: string): string
-decrypt(encryptedData: string, key: string): any
-```
----
-## Interceptors
-### RequestErrorInterceptor
-**Description:** Handles HTTP error responses with toast notifications.
-**Features:**
-- 4xx errors → Warning toast
-- 5xx errors → Error toast
-- Detailed console logging
-**Installation:**
-```typescript
-providers: [
-  { provide: HTTP_INTERCEPTORS, useClass: RequestErrorInterceptor, multi: true }
-]
-```
----
-### RequestHeadersInterceptor
-**Description:** Automatically adds common headers to requests.
-**Headers Added:**
-- `Content-Type: application/json`
-- `Accept-Language: {locale}-CA`
-- `Current-Date: YYYY-MM-DD`
-**Installation:**
-```typescript
-providers: [
-  { provide: HTTP_INTERCEPTORS, useClass: RequestHeadersInterceptor, multi: true }
-]
-```
----
-### CredentialsInterceptor
-**Description:** Adds `withCredentials: true` to all requests.
-**Installation:**
-```typescript
-providers: [
-  { provide: HTTP_INTERCEPTORS, useClass: CredentialsInterceptor, multi: true }
-]
-```
----
-### ProxyDebuggerInterceptor
-**Description:** Logs request/response details for debugging.
-**Installation:**
-```typescript
-providers: [
-  { provide: HTTP_INTERCEPTORS, useClass: ProxyDebuggerInterceptor, multi: true }
-]
-```
----
-## Models & Configuration
-### ApiRequest
-Configuration for HTTP requests.
-```typescript
-interface ApiRequest {
-  server: string;                    // Base URL
-  path: any[];                       // Path segments
-  headers: any;                      // Custom headers
-  adapter: Function;                 // Response transformer
-  mapper: Function;                  // Request transformer
-  polling: number;                   // Polling interval (seconds)
-  retry: RetryOptions;               // Retry config
-  stream: boolean;                   // Enable streaming
-  displayError: boolean;             // Show error toast
-  saveAs: string;                    // Download filename
-  ws: WSOptions;                     // WebSocket config
-}
-```
-### DatabaseStorage
-Configuration for IndexedDB caching.
-```typescript
-interface DatabaseStorage {
-  table: string;                     // Table name
-  expiresIn: string;                 // '1h', '30mn', '5mn'
-}
-```
-### WSOptions
-WebSocket connection configuration.
-```typescript
-interface WSOptions {
-  wsServer: string;                  // WebSocket server URL
-  id: string;                        // Channel ID
-  user: any;                         // User info
-  channels?: string[];               // Additional channels
-  jwtToken?: string;                 // JWT token
-  retry?: { times: number; delay: number };
-}
-```
-### SettingOptions
-LocalStorage configuration.
-```typescript
-interface SettingOptions {
-  storage: StorageType;              // GLOBAL or SESSION
-  encrypted: boolean;                // Enable encryption
-  expiresIn?: string;                // Expiration duration
-}
-```
-### TableSchemaDef
-IndexedDB table schema definition.
-```typescript
-interface TableSchemaDef {
-  table: string;                     // Table name
-  schema: string;                    // Dexie schema (e.g., '++id, name, email')
-}
-```
-### DataType
-Enum for data structure type.
-```typescript
-enum DataType {
-  ARRAY = 'array',                   // List data
-  OBJECT = 'object'                  // Single object
-}
-```
-### StorageType
-Enum for storage location.
-```typescript
-enum StorageType {
-  GLOBAL = 'global',                 // LocalStorage
-  SESSION = 'session'                // SessionStorage
-}
-```
----
-## Quick Reference
-### Service Injection
-```typescript
-// HTTP (Observable)
-httpManager = inject(HTTPManagerService);
-// HTTP (Signals)
-httpManager = inject(HTTPManagerSignalsService);
-// State Management
-stateStore = inject(HTTPManagerStateService);
-// WebSocket
-wsManager = inject(WebSocketManagerService);
-// LocalStorage
-localStorage = inject(LocalStorageManagerService);
-// IndexedDB
-dbManager = inject(DatabaseManagerService);
-// Utilities
-utils = inject(UtilsService);
-```
-### Common Patterns
-#### Fetch and Display
-```typescript
-// Observable
-data$ = this.httpManager.data$;
-httpManager.getRequest(ApiRequest.adapt({ path: ['users'] })).subscribe();
-// Signal
-data = this.httpManager.data;
-httpManager.getRequest(ApiRequest.adapt({ path: ['users'] })).subscribe();
-```
-#### Create Record
-```typescript
-// State Service
-stateStore.createRecord(newData, { path: ['users'] });
-// HTTP Service
-httpManager.postRequest(newData, ApiRequest.adapt({ path: ['users'] })).subscribe();
-```
-#### Clear Cache
-```typescript
-// Clear IndexedDB
-stateStore.clearDatabase();
-// Clear specific table
-dbManager.clearTable('users').subscribe();
-```
-#### WebSocket Messaging
-```typescript
-// Connect (singleton)
-wsManager.connect(options, jwtToken);
-// Subscribe
-wsManager.subscribeToChannel('chat-room');
-// Send
-wsManager.sendChannelMessage('chat-room', { text: 'Hello' });
-```
----
-This API reference provides comprehensive documentation for all services in the HTTP Request Manager library. For more detailed examples and use cases, refer to the individual README files in the `docs/` folder.