http-request-manager 18.15.34 → 18.16.1

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

@@ -1,2395 +0,0 @@
-import { inject, Inject, Injectable, InjectionToken } from '@angular/core';
-import { ComponentStore } from '@ngrx/component-store';
-
-import { BehaviorSubject, Observable, of, Subject, merge, Subscription } from 'rxjs';
-import { tap, switchMap, concatMap, scan, delay, take, map, distinctUntilChanged, filter, catchError, finalize } from 'rxjs/operators';
-import { DatabaseStorage } from '../../models/database-storage.model';
-import { ApiRequest, RequestOptions, WSOptions, OperationResultModel } from './models';
-import { WSUser } from '../ws-manager-service/models';
-import { HTTPManagerService, DataType } from '../request-manager-services';
-import { DatabaseManagerService } from '../database-manager-service';
-import { TableSchemaDef } from '../database-manager-service/models/table-schema';
-import { LocalStorageManagerService, StorageType } from '../local-storage-manager-service';
-import { SettingOptions } from '../local-storage-manager-service/models/setting-options.model';
-import { UtilsService } from '../..';
-import { ChannelMessage } from '../ws-manager-service/models/channel-message.model';
-import { WebSocketManagerService } from '../ws-manager-service/websocket-service';
-import { LoggerService } from '../../services/utils/logger.service';
-// import { QueryParamsTrackerService } from '../utils/query-params-tracker.service';
-
-const API_OPTS = new InjectionToken<ApiRequest>('API_OPTS');
-
-/**
- * Channel type enum for different communication purposes
- * - STATE: Private channels for state synchronization (SYS- prefix)
- * - MESSAGE: Public messaging/communication channels (PUB- prefix)
- * - NOTIFICATION: Notification channels with DB persistence (MES- prefix)
- */
-export enum ChannelType {
-  STATE = 'SYS',
-  MESSAGE = 'PUB',
-  NOTIFICATION = 'MES'
-}
-
-/**
- * Utility function to create prefixed channel name
- * @param channelType - The type of channel
- * @param channelName - The base channel name
- * @returns Prefixed channel name (e.g., 'SYS-USERS123')
- */
-export function createChannelName(channelType: ChannelType, channelName: string): string {
-  return `${channelType}-${channelName}`;
-}
-
-export interface APIStateManagerData<T> {
-  data: T[]
-  dataObject: T | null
-}
-
-const defaultState: APIStateManagerData<any> = {
-  data: [],
-  dataObject: null,
-};
-
-@Injectable()
-export class HTTPManagerStateService<T extends { id: number|string }> extends ComponentStore<APIStateManagerData<T>> {
-
-  httpManagerService = inject(HTTPManagerService)
-  dbManagerService = inject(DatabaseManagerService)
-  localStorageManagerService = inject(LocalStorageManagerService)
-  utils = inject(UtilsService)
-  logger = inject(LoggerService)
-  // private queryParamsTrackerService = inject(QueryParamsTrackerService)
-
-  error$ = this.httpManagerService.error$
-  isPending$ = this.httpManagerService.isPending$.pipe(delay(1))
-
-  private operationSuccess = new BehaviorSubject<OperationResultModel | null>(null)
-  operationSuccess$ = this.operationSuccess.asObservable()
-
-  // PAGINATION
-  private page = new BehaviorSubject<number>(0)
-  page$ = this.page.asObservable()
-
-  private totalPages = new BehaviorSubject<number>(0)
-  totalPages$ = this.totalPages.asObservable()
-
-  private percentage = new BehaviorSubject<number>(0)
-  percentage$ = this.percentage.asObservable()
-
-  private hasDatabase = false
-
-  streamedResponse: any[] = []
-
-  // WS
-  private maxRetries: number
-  private retryDelay: number
-  private shouldRetry = true
-
-  // Track connection status subscription to prevent duplicates
-  private connectionStatusSubscription?: Subscription
-
-  private databaseOptions?: DatabaseStorage
-
-  private readonly volatileHeaders = new Set([
-    'authorization',
-    'x-request-id',
-    'x-correlation-id',
-    'x-trace-id',
-    'x-amzn-trace-id',
-    'date',
-    'if-none-match'
-  ])
-
-  private requestSignatureCache: Record<string, { GET?: string; STREAM?: string }> = {}
-  private inFlightRequestSignatures = new Set<string>()
-  private _requestCachePaths = new Map<string, string[]>()
-
-  private wsRetryAttempts = new BehaviorSubject<number>(0)
-  wsRetryAttempts$ = this.wsRetryAttempts.asObservable()
-
-  private wsNextRetry: BehaviorSubject<number>
-  wsNextRetry$: Observable<number>
-
-
-  private messages = new BehaviorSubject<any[]>([])
-  messages$ = this.messages.asObservable()
-
-  private userListByChannel = new BehaviorSubject<Map<string, any[]>>(new Map())
-  userListByChannel$ = this.userListByChannel.asObservable()
-
-  // Convenience observable that returns users for a specific channel
-  getUsersForChannel$(channel: string) {
-    return this.userListByChannel$.pipe(
-      map(channelMap => channelMap.get(channel) || [])
-    )
-  }
-
-  // Returns all unique users across all channels
-  private userList = new BehaviorSubject<any[]>([])
-  userList$ = this.userList.asObservable()
-
-  private user = new BehaviorSubject<WSUser|null>(null)
-  user$ = this.user.asObservable()
-
-  private channels = new BehaviorSubject<string[]|null>(null)
-  channels$ = this.channels.asObservable()
-
-  // In-memory notification channels (from server)
-  private notificationChannels = new BehaviorSubject<string[]>([])
-  notificationChannels$ = this.notificationChannels.asObservable()
-
-  // Today's notification channels (from database - channels with data for today)
-  private todaysNotificationChannels = new BehaviorSubject<string[]>([])
-  todaysNotificationChannels$ = this.todaysNotificationChannels.asObservable()
-
-  // Notification messages (MES- channels)
-  private notificationMessages = new BehaviorSubject<any[]>([])
-  notificationMessages$ = this.notificationMessages.asObservable()
-
-  private latestNotification = new Subject<any>()
-  latestNotification$ = this.latestNotification.asObservable()
-
-  private communicationMessages = new BehaviorSubject<any[]>([])
-  communicationMessages$ = this.communicationMessages.asObservable()
-
-  private latestCommunicationMessages = new BehaviorSubject<any|null>(null)
-  latestCommunicationMessages$ = this.latestCommunicationMessages.asObservable()
-
-  private userAction = new BehaviorSubject<any|null>(null)
-  userAction$ = this.userAction.asObservable()
-
-  // Message queue for WebSocket communication (processed when connection is established)
-  private static wsCommunicationQueue: Array<{method: string, path?: string|number[]}> = [];
-
-  // Store our own sessionId for filtering out own messages
-  private ownSessionId: string | null = null;
-
-  wsOptions = WSOptions.adapt()
-
-  // Expose raw WS connection status directly to UI (from singleton WebSocketManagerService)
-  public connectionStatus$: Observable<boolean> = this.httpManagerService.connectionStatus$
-  public wsRetryCount$: Observable<number> = this.httpManagerService.retryCount$
-  public wsMaxRetries$: Observable<number> = this.httpManagerService.maxRetries$
-
-  constructor(
-    @Inject(API_OPTS) private apiOptions = ApiRequest.adapt(),
-    @Inject("dataType") private dataType: DataType | undefined,
-    database?: DatabaseStorage
-  ) {
-
-    super(defaultState);
-
-    try {
-      this.databaseOptions = database
-      this.hasDatabase = (database?.table) ? true : false
-      this.maxRetries = this.apiOptions.ws?.retry?.times || 3
-      this.retryDelay = (this.apiOptions.ws?.retry?.delay && this.apiOptions.ws.retry.delay * 1000) || 5 * 1000
-
-      // Start next retry countdown at 0 to avoid showing 5000 pre-connection
-      this.wsNextRetry = new BehaviorSubject<number>(0)
-      this.wsNextRetry$ = this.wsNextRetry.asObservable()
-
-      this.setApiRequestOptions(apiOptions, dataType, database)
-
-      if (this.databaseOptions && this.databaseOptions.table) {
-
-        this.localStorageManagerService.createStore({
-          name: this.databaseOptions.table,
-          data: { ...this.databaseOptions, ...{ expires: this.utils.expires(this.databaseOptions.expiresIn)} },
-          options: SettingOptions.adapt({
-            storage: StorageType.GLOBAL,
-            encrypted: false,
-          })
-        })
-
-        // Use initDBStorageAsync directly - the effect initDBStorage requires subscription
-        this.initDBStorageAsync().subscribe({
-          next: () => console.log('[Constructor] Database storage initialized'),
-          error: (err: any) => console.error('[Constructor] Database storage initialization failed:', err)
-        })
-
-      }
-    } catch (error) {
-      this.logger.error('HTTPManagerStateService', 'Error initializing', error);
-      // Initialize with safe defaults
-      this.databaseOptions = undefined;
-      this.maxRetries = 3;
-      this.retryDelay = 5000;
-      this.wsNextRetry = new BehaviorSubject<number>(0);
-      this.wsNextRetry$ = this.wsNextRetry.asObservable();
-    }
-
-  }
-
-  /**
-   * Add appropriate prefix to a channel name if not already present
-   */
-  private prefixChannel(channel: string, type: ChannelType): string {
-    const prefix = `${type}-`;
-    if (channel.startsWith(prefix)) {
-      return channel;
-    }
-    // Remove any other known prefix before adding the correct one
-    const cleanChannel = this.stripChannelPrefix(channel);
-    return `${type}-${cleanChannel}`;
-  }
-
-  /**
-   * Remove any known prefix from a channel name
-   */
-  private stripChannelPrefix(channel: string): string {
-    for (const type of Object.values(ChannelType)) {
-      const prefix = `${type}-`;
-      if (channel.startsWith(prefix)) {
-        return channel.slice(prefix.length);
-      }
-    }
-    return channel;
-  }
-
-  /**
-   * Get the base channel name without prefix (for display/user reference)
-   */
-  getBaseChannelName(channel: string): string {
-    return this.stripChannelPrefix(channel);
-  }
-
-  setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage) {
-
-    this.logger.debug('StateStore', '🔧 setApiRequestOptions called', {
-      hasWs: !!apiOptions?.ws,
-      wsId: apiOptions?.ws?.id,
-      wsServer: apiOptions?.ws?.wsServer,
-      path: apiOptions?.path
-    });
-
-    this.apiOptions = ApiRequest.adapt(apiOptions)
-    this.dataType = (dataType) ? dataType : DataType.ARRAY
-
-    // Only update database options if a database parameter is explicitly provided
-    if (database !== undefined) {
-      console.log('[setApiRequestOptions] Database config:', {
-        database,
-        hasTable: !!database?.table,
-        tableValue: database?.table
-      })
-      this.hasDatabase = (database?.table) ? true : false
-      const adapted = DatabaseStorage.adapt(database)
-      console.log('[setApiRequestOptions] DatabaseStorage.adapt result:', adapted)
-      this.databaseOptions = (this.hasDatabase) ? adapted : undefined
-
-      // Trigger database table creation if table is configured
-      if (this.hasDatabase && this.databaseOptions?.table) {
-        this.localStorageManagerService.createStore({
-          name: this.databaseOptions.table,
-          data: {
-            ...this.databaseOptions,
-            expires: this.utils.expires(this.databaseOptions.expiresIn),
-          },
-          options: SettingOptions.adapt({
-            storage: StorageType.GLOBAL,
-            encrypted: false,
-          })
-        })
-
-        console.log('[setApiRequestOptions] Initializing database storage for table:', this.databaseOptions.table)
-        // Use initDBStorageAsync directly instead of the effect - effects need subscription to run
-        this.initDBStorageAsync().subscribe({
-          next: () => console.log('[setApiRequestOptions] Database storage initialized successfully'),
-          error: (err: any) => console.error('[setApiRequestOptions] Database storage initialization failed:', err)
-        })
-
-        // Pre-populate _requestCachePaths so clearRequestCacheMetadata works after browser refresh
-        // (before any GET request has run to populate it via saveRequestCacheMetadata)
-        this._requestCachePaths.set(
-          this.databaseOptions.table,
-          this.resolvePath().filter(p => typeof p === 'string' || typeof p === 'number').map(String)
-        )
-      }
-    }
-
-    if(this.apiOptions.ws && this.apiOptions.ws.id !== '') {
-
-      // Auto-prefix channel ID for private state manager channels
-      // This ensures state manager channels are separate from user-defined channels
-      this.apiOptions.ws.id = this.prefixChannel(this.apiOptions.ws.id, ChannelType.STATE);
-      this.logger.debug('StateStore', `🔒 Private state channel configured`, { channelId: this.apiOptions.ws.id });
-
-      // Store our own sessionId for filtering incoming messages
-      this.ownSessionId = sessionStorage.getItem('WSID') || null;
-      this.logger.debug('StateStore', `🆔 Stored own sessionId for message filtering`, { sessionId: this.ownSessionId });
-      this.logger.debug('StateStore', `🔍 WebSocket configuration`, {
-        channelId: this.apiOptions.ws.id,
-        wsServer: this.apiOptions.ws.wsServer,
-        sessionId: this.ownSessionId,
-        path: this.apiOptions.path
-      });
-
-      // Initialize WebSocket connection if not already connected
-      this.logger.debug('StateStore', '🔌 Checking WebSocket connection status...');
-      this.logger.debug('StateStore', '🔌 Is connected?', { connected: WebSocketManagerService.isConnected() });
-
-      if (!WebSocketManagerService.isConnected()) {
-        this.logger.debug('StateStore', '🔌 WebSocket not connected, will initialize via effect');
-        // initWS is an effect that triggers when setApiRequestOptions is called with ws config
-        // The effect is already triggered by calling setApiRequestOptions above
-      }
-
-      if (this.apiOptions.ws?.retry) {
-        this.maxRetries = this.apiOptions.ws.retry.times || 3
-        this.retryDelay = (this.apiOptions.ws.retry.delay && this.apiOptions.ws.retry.delay * 1000) || 5 * 1000
-        this.wsNextRetry.next(this.retryDelay)
-      }
-
-      // Validate wsServer before attempting connection
-      if (!this.apiOptions.ws.wsServer || this.apiOptions.ws.wsServer === '') {
-        this.logger.error('StateStore', 'WSOptions invalid: wsServer is missing or empty');
-        return;
-      }
-
-      // Clean up previous subscription to prevent duplicate handlers
-      if (this.connectionStatusSubscription) {
-        this.connectionStatusSubscription.unsubscribe();
-        this.connectionStatusSubscription = undefined;
-      }
-
-      // Setup connection status monitoring (internal subscription to drive retry counters)
-      this.connectionStatusSubscription = this.setupConnectionStatus().subscribe();
-
-      // Make initial connection attempt
-      this.logger.debug('StateStore', '🔄 Initial WebSocket connection attempt...');
-      this.httpManagerService.connect(this.apiOptions.ws as WSOptions, this.apiOptions.ws.jwtToken || '');
-
-      // Initialize WS effect to handle messages
-      this.initWS(this.apiOptions.ws as WSOptions);
-
-    } else {
-      this.logger.warn('StateStore', 'WSOptions invalid Id: empty');
-    }
-  }
-
-  // WebSocket
-  private setupConnectionStatus(): Observable<boolean> {
-    return this.httpManagerService.connectionStatus$.pipe(
-      distinctUntilChanged(),
-      tap(status => {
-        if (status === true) {
-          this.logger.debug('StateStore', '🟢 WebSocket connection is open')
-        } else {
-          this.logger.debug('StateStore', '🔴 WebSocket connection is closed')
-        }
-      }),
-      map(status => {
-
-        if (status === true) {
-          this.shouldRetry = true
-          this.wsRetryAttempts.next(0)
-          this.wsNextRetry.next(0)
-          return true
-        }
-
-        // Retry orchestration is centralized in WebSocketManagerService.connect/onclose
-        // and uses ws.retry from request options. Keep this stream as status/state only.
-        if (!this.shouldRetry) {
-          this.wsRetryAttempts.next(0)
-          this.wsNextRetry.next(0)
-          return false
-        }
-
-        const nextAttempt = Math.min(this.wsRetryAttempts.value + 1, this.maxRetries)
-        this.wsRetryAttempts.next(nextAttempt)
-        this.wsNextRetry.next(nextAttempt >= this.maxRetries ? 0 : this.retryDelay / 1000)
-        return false
-      })
-    );
-  }
-
-  // WebSocket
-  readonly initWS = this.effect<WSOptions>((wsOptions$) =>
-    wsOptions$.pipe(
-      switchMap((wsOptions) =>
-        merge(
-          this.httpManagerService.connectionStatus$.pipe(
-            tap((isConnected: any) => {
-              if (isConnected) {
-                // Subscribe to our private SYS- state channel so we receive stateMangerMessage broadcasts
-                // This is the critical subscription that enables multi-client state syncing
-                const stateChannel = wsOptions?.id || this.apiOptions.ws?.id;
-                if (stateChannel) {
-                  console.log(`🔒 [STATE STORE] Subscribing to state channel: ${stateChannel}`);
-                  this.httpManagerService.subscribeToChannel(stateChannel);
-                }
-
-                // Process queued wsCommunication calls when connection becomes true
-                if (HTTPManagerStateService.wsCommunicationQueue.length > 0) {
-                  console.log(`🔄 Processing ${HTTPManagerStateService.wsCommunicationQueue.length} queued WS messages`);
-                  while (HTTPManagerStateService.wsCommunicationQueue.length > 0) {
-                    const queued = HTTPManagerStateService.wsCommunicationQueue.shift()!;
-                    this.sendWsCommunication(queued.method, queued.path);
-                  }
-                }
-              }
-            })
-          ),
-          this.httpManagerService.messages$.pipe(
-            tap((message: any) => {
-              if (!message) return
-
-              // CRITICAL DEBUG: Log EVERY message received
-              console.log('🔍 [STATE STORE] Received WebSocket message:', {
-                type: message.type,
-                channel: message.channel,
-                sessionId: message.data?.sessionId?.id || message.sessionId?.id,
-                content: message.content || message.data?.content,
-                timestamp: new Date().toISOString()
-              });
-
-              // Add message to messages array
-              const currentMessages = this.messages.value
-              this.messages.next([...currentMessages, message])
-
-              console.log('Received:', message)
-
-              // Debug: Log all message types
-              this.logger.debug('StateStore', '📨 Message type', { type: message.type })
-
-              if (message.error === 'JWT_INVALID' || message.error === 'AUTH_BLOCKED') {
-                this.shouldRetry = false
-                this.httpManagerService.disconnect()
-              }
-
-              if (message.type === 'success') {
-                if(message.data.id !== this.user.value?.id) {
-                  const user = WSUser.adapt(message.data)
-                  this.user.next(user)
-                }
-              }
-
-              switch (message.type) {
-                case 'channelsList':
-
-                  this.logger.debug('StateStore', '💬 Channels', { channels: message.channels })
-                  this.logger.debug('StateStore', '🔍 channelsList received, checking connection status...')
-                  this.logger.debug('StateStore', '🔍 WebSocket connected', { connected: WebSocketManagerService.isConnected() })
-
-                  // Extract channel names from metadata objects (new format) or use strings directly (old format)
-                  const channelNames = message.channels.map((c: any) => {
-                    // Handle new format: {name: string, canSubscribe: boolean}
-                    if (typeof c === 'object' && c.name) {
-                      return c.name;
-                    }
-                    // Handle old format: string
-                    return c;
-                  });
-
-                  // Auto-subscribe to all channels from the list
-                  if (channelNames && channelNames.length > 0) {
-                    this.logger.debug('StateStore', '📥 Auto-subscribing to channels', { count: channelNames.length })
-                    this.subscribeToChannels(channelNames)
-                  } else {
-                    this.logger.warn('StateStore', '⚠️ No channels to subscribe to')
-                  }
-
-                  this.channels.next(channelNames)
-
-                  break;
-
-                case 'success':
-                  // Success messages - check for subscription confirmation
-                  this.logger.info('StateStore', `✅ Success`, { message: message.message })
-                  if (message.message?.includes('Subscribed to channel:')) {
-                    // Extract channel name from message: "Subscribed to channel: PUB-chat"
-                    const channelName = message.message.split('Subscribed to channel:')[1]?.trim()
-                    this.logger.debug('StateStore', `✅ Subscription confirmed for channel`, { channel: channelName })
-                    WebSocketManagerService.addSubscribedChannel(channelName)
-                  }
-                  break;
-
-                case 'subscribed':
-                  this.logger.debug('StateStore', `✅ Subscription confirmed`, { channel: message.channel })
-                  // Track as subscribed now that server confirmed
-                  WebSocketManagerService.addSubscribedChannel(message.channel);
-                  break;
-
-                case 'unsubscribed':
-                  this.logger.debug('StateStore', `🔓 Unsubscription confirmed`, { channel: message.channel })
-                  break;
-
-                case 'info':
-                  // Already subscribed or other info messages
-                  this.logger.info('StateStore', `ℹ️ Info`, { message: message.message })
-                  // If it's an "Already subscribed" message, treat it as subscription confirmation
-                  if (message.message?.includes('Already subscribed to channel:')) {
-                    // Extract channel name from message: "Already subscribed to channel: PUB-chat"
-                    const channelName = message.message.split('Already subscribed to channel:')[1]?.trim()
-                    console.log(`✅ Treating info as subscription confirmation for channel: ${channelName}`)
-                    WebSocketManagerService.addSubscribedChannel(channelName)
-                  }
-                  break;
-
-                case 'statemanagerMessage':
-                case 'stateMangerMessage':
-                  // CRITICAL DEBUG: Log channel comparison
-                  console.log('🔍 [STATE STORE] stateMangerMessage received:', {
-                    messageChannel: message.channel,
-                    ourChannel: this.apiOptions.ws?.id,
-                    channelsMatch: message.channel === this.apiOptions.ws?.id,
-                    senderSessionId: message.data.sessionId?.id,
-                    ourSessionId: this.ownSessionId
-                  });
-
-                  // Compare sender's session ID with our own sessionId
-                  // message.data.sessionId is an object with 'id' property from server
-                  const stateManagerSenderId = message.data.sessionId?.id || message.data.sessionId;
-                  console.log('🔍 State Manager: Sender sessionId:', stateManagerSenderId, 'Own sessionId:', this.ownSessionId);
-                  if(stateManagerSenderId !== this.ownSessionId) {
-                    console.log('💬 State Manager Message:', message.data)
-                    console.log('📥 Fetching record with path:', message.data.content.path, 'method:', message.data.content.method)
-                    this.userAction.next(message.data)
-                    this.fetchRecord(RequestOptions.adapt({ path: message.data.content.path }), message.data.content.method)
-                  } else {
-                    console.log('⏭️ Skipping own message (sessionId match)');
-                  }
-                  break;
-
-                case 'channelMessage':
-                  // Handle channel-based messages (from sendChannelMessage)
-                  // Structure: { type: 'channelMessage', messageId, channel, sessionId, content, timestamp }
-                  // Skip messages from self
-                  const senderSessionId = message.sessionId?.id || message.sessionId;
-                  if (senderSessionId === this.ownSessionId) {
-                    console.log('🔇 Skipping message from self (sessionId match)');
-                    break;
-                  }
-
-                  console.log('💬 Channel Message received:', message);
-
-                  // Determine which channels this message was sent to
-                  const messageChannels = message.channel ? [message.channel] : [];
-
-                  // Construct expected channel path (without env prefix)
-                  const myPath = this.apiOptions.path || [];
-                  const myPathString = myPath.join('/');
-
-                  // Check if any of the message channels CONTAIN our path
-                  const isWsUpdateChannel = messageChannels.some((ch: string) => {
-                    // Strip SYS- prefix if present for comparison
-                    const cleanChannel = ch.replace('SYS-', '');
-                    // Check if channel contains our path (or starts with it)
-                    const matches = cleanChannel === myPathString ||
-                                   cleanChannel.startsWith(myPathString + '/') ||
-                                   cleanChannel.includes(myPathString);
-                    console.log(`🔍 Channel check: ${ch} contains ${myPathString}? ${matches}`);
-                    return matches;
-                  });
-
-                  // If it's the expected channel, trigger fetchRecord like stateManagerMessage
-                  if (isWsUpdateChannel && message.content?.path) {
-                    console.log('🔍 Message received on expected channel (path match):', myPathString);
-                    console.log('📄 Content:', message.content);
-
-                    console.log('📥 Fetching record for channel:', myPathString);
-                    const path = message.content.path;
-                    const method = message.content.method || 'UPDATE';
-                    this.userAction.next({ sessionId: message.sessionId, content: message.content });
-                    this.fetchRecord(RequestOptions.adapt({ path }), method);
-
-                  } else if (message.content) {
-                    // Handle message content directly
-                    console.log('📄 Processing message content:', message.content);
-                    this.appendMessages(ChannelMessage.adapt({
-                      sessionId: message.sessionId,
-                      content: message.content,
-                    }));
-
-                  } else {
-                    console.log('⚠️ Message does not contain data.content.path, skipping fetchRecord');
-                  }
-
-                  // Keep existing functionality for backward compatibility
-                  if (message.data?.content && !isWsUpdateChannel) {
-                    this.appendMessages(ChannelMessage.adapt({
-                      sessionId: message.data.sessionId,
-                      content: message.data.content,
-                    }));
-                  }
-                  break;
-
-                case 'usersInChannel':
-                  console.log(`👥 Users in channel "${message.channel}":`, message.data.users)
-
-                  // Update channel-specific user list
-                  const currentMap = new Map(this.userListByChannel.value)
-                  currentMap.set(message.channel, message.data.users)
-                  this.userListByChannel.next(currentMap)
-
-                  // Update legacy userList with unique users across all channels
-                  const allUsers = Array.from(currentMap.values()).flat()
-                  const uniqueUsers = allUsers.filter((user, index, self) =>
-                    index === self.findIndex(u => u.id === user.id)
-                  )
-                  this.userList.next(uniqueUsers)
-                  break;
-
-                case 'notificationChannelsList':
-                  console.log('📢 Notification Channels (in-memory):', message.channels)
-                  // Extract channel names from metadata objects (new format) or use strings directly (old format)
-                  const notifyChannelNames = message.channels.map((c: any) => {
-                    if (typeof c === 'object' && c.name) {
-                      return c.name;
-                    }
-                    return c;
-                  });
-                  this.notificationChannels.next(notifyChannelNames || [])
-                  break;
-
-                case 'todaysNotificationChannelsList':
-                  console.log('📢 Today\'s Notification Channels (from DB):', message.channels)
-                  // Extract channel names from metadata objects (new format) or use strings directly (old format)
-                  const todaysNotifyChannelNames = message.channels.map((c: any) => {
-                    if (typeof c === 'object' && c.name) {
-                      return c.name;
-                    }
-                    return c;
-                  });
-                  this.todaysNotificationChannels.next(todaysNotifyChannelNames || [])
-                  break;
-
-                case 'notificationSubscribed':
-                  console.log(`📢 Notification subscription confirmed: ${message.channel}`, message.notifications)
-                  // Set historical notifications from subscription
-                  if (message.notifications && Array.isArray(message.notifications)) {
-                    this.notificationMessages.next(message.notifications)
-                  }
-                  break;
-
-                case 'notificationUnsubscribed':
-                  console.log(`📢 Notification unsubscription confirmed: ${message.channel}`)
-                  break;
-
-                case 'notification':
-                  console.log('📢 Notification received:', message)
-                  // Add to notifications array
-                  const currentNotifications = this.notificationMessages.value
-                  this.notificationMessages.next([...currentNotifications, message])
-                  // Emit as latest notification
-                  this.latestNotification.next(message)
-                  break;
-
-                default:
-                  // Messages are already added at the beginning of the tap
-                  break
-              }
-            })
-          )
-        )
-      )
-    )
-  );
-
-  appendMessages(message: any) {
-    const currentMessages = this.communicationMessages.value
-    this.communicationMessages.next([...currentMessages, message])
-    this.latestMessage()
-  }
-
-  latestMessage() {
-    const messages = this.communicationMessages.value
-    const latestMessage = messages[messages.length -1]
-    this.latestCommunicationMessages.next(latestMessage)
-  }
-
-  clearMessages() {
-    this.communicationMessages.next([])
-  }
-
-  get ApiRequestOptions() {
-    return this.apiOptions
-  }
-
-  readonly initDBStorage = this.effect<void>((trigger$) =>
-    trigger$.pipe(
-      tap(() => {
-        console.log('[initDBStorage effect] Triggered, checking conditions:', {
-          dataType: this.dataType,
-          isARRAY: this.dataType === DataType.ARRAY,
-          hasAdapter: !!this.apiOptions?.adapter,
-          hasTable: !!this.databaseOptions?.table,
-          tableValue: this.databaseOptions?.table
-        })
-        if (this.dataType !== DataType.ARRAY) console.warn('Database storage requires dataType to be ARRAY')
-        if (!this.apiOptions.adapter) console.warn('Database storage adapter missing, using minimal or inferred schema')
-        if (this.databaseOptions && this.databaseOptions?.table === '') console.warn('Database storage requires a table name')
-      }),
-      filter(() => {
-        const shouldProceed = this.dataType === DataType.ARRAY && !!this.databaseOptions?.table
-        console.log('[initDBStorage effect] Filter result:', shouldProceed)
-        return shouldProceed
-      }),
-      switchMap(() => {
-        const schema = this.buildSchemaFromAdapter()
-
-        const tableDef = TableSchemaDef.adapt({
-          table: this.databaseOptions?.table,
-          schema: schema
-        });
-
-        return this.dbManagerService.createDatabaseTable(tableDef)
-      })
-    )
-  )
-
-  initializeState(data: any) {
-    this.setData$(data)
-  }
-
-  // --------------------------------------------------------------------------------------------------
-  // SELECTORS
-  readonly data$ = this.select(({ data, dataObject }) => {
-    const isArray =( this.dataType === DataType.ARRAY) ? true : false
-    return (isArray) ? data : dataObject
-  })
-
-  readonly selectRecord$ = (id: number) => this.select(
-    this.data$,
-    (data) => {
-      if (this.dataType === DataType.ARRAY && Array.isArray(data)) {
-        return data.find(item => item.id === id) as T | null
-      } else {
-        return (data as T).id === id ? data : null
-      }
-    }
-  )
-
-  // --------------------------------------------------------------------------------------------------
-
-  // UPDATERS
-  private readonly setData$ = this.updater((state: APIStateManagerData<T>, data: T | T[] | any) => {
-
-    if (!data) return state;
-
-    if (this.dataType === DataType.ARRAY) {
-
-      const dataArray = Array.isArray(data) ? data : [data]
-
-      const stateDataSample = (state.data.length > 0) ? Object.keys(state.data[0]) : []
-      const newDataSample = (dataArray.length > 0) ? Object.keys(dataArray[0]) : []
-
-      const isSame = (state.data.length === 0) ? false : stateDataSample.every((value, index) => value === newDataSample[index])
-      const updatedData = (!isSame && dataArray.length !== 0) ? this.updateArrayState([], dataArray) : this.updateArrayState(state.data, dataArray)
-
-      return { ...state, data: updatedData, dataObject: null } as APIStateManagerData<T>;
-
-    } else {
-      const dataObject = this.isEmpty(data) ? null : data;
-      return { ...state, data: [], dataObject: dataObject } as APIStateManagerData<T>;
-    }
-
-  })
-
-  private updateArrayState(currentData: any[], newData: any[]): any[] {
-
-    // For non-streaming requests (GET), REPLACE data entirely
-    // For streaming requests, MERGE with existing data incrementally
-    if (this.streamedResponse.length === 0) {
-      // GET request: return new data as-is (replace)
-      return newData
-    }
-
-    // Streaming: merge with existing data
-    const filterCurrentData = () => {
-      const ids = this.streamedResponse.map((obj: any) => obj.id)
-      return currentData.filter(obj => (obj.id) ? ids.includes(obj.id) : obj)
-    }
-
-    const filteredCurrentData = (this.httpManagerService.isPending.value)
-      ? currentData
-      : filterCurrentData()
-
-    const updatedData = filteredCurrentData.map(item => {
-        const newItem = newData.find(newItem => {
-          const hasId = (newItem?.id && item?.id) ? true : false
-          return (hasId) ? newItem.id === item.id : JSON.stringify(newItem) === JSON.stringify(item)
-        })
-        return (newItem) ? { ...item, ...newItem } : item
-    })
-
-    const addedData = newData.filter(newItem => {
-      return !filteredCurrentData.some(item => {
-          const hasId = (newItem?.id && item?.id) ? true : false
-          return (hasId) ? item.id === newItem.id : JSON.stringify(newItem) === JSON.stringify(item)
-      })
-    })
-
-    return [...updatedData, ...addedData]
-
-  }
-
-  private readonly addData$ = this.updater((state: APIStateManagerData<T>, data: T) => {
-
-    if (this.dataType === DataType.ARRAY) {
-      const exists = state.data.some(item => item.id === data.id);
-
-      if (exists) {
-          const updatedData = state.data.map(item =>
-          item.id === data.id ? data : item
-        );
-
-        return { ...state, data: updatedData };
-      } else {
-        const newState = [...state.data, data];
-        return { ...state, data: newState };
-      }
-    } else {
-      return { ...state, dataObject: data };
-    }
-
-  })
-
-  private readonly deleteData$ = this.updater((state: APIStateManagerData<T>, data: T & { id: number }) => {
-    if (this.dataType === DataType.ARRAY) {
-    const newState = state.data.filter(item => item.id !== data.id)
-    return { ...state, ...{ data: newState } }
-    } else {
-      return { ...state, ...{ dataObject: null } }
-    }
-  })
-
-  private readonly updateData$ = this.updater((state: APIStateManagerData<T>, data: T) => {
-
-    if (this.dataType === DataType.ARRAY) {
-
-      const objIndex = state.data.findIndex(item => item.id === data.id)
-
-      if (objIndex > -1) {
-        const newState = [...state.data]
-        newState[objIndex] = data
-        return { ...state, ...{ data: newState } }
-      }
-
-      return state
-
-    } else {
-      return { ...state, ...{ dataObject: data } }
-    }
-
-  })
-
-  // --------------------------------------------------------------------------------------------------
-  // EFFECTS
-  readonly clearRecords = this.effect(data =>
-    data.pipe(
-
-      tap(() => {
-
-        if (this.dataType === DataType.ARRAY) {
-          this.setData$([])
-        } else {
-          this.setData$({})
-        }
-
-      }),
-      concatMap(() => {
-        if (this.hasDatabase && this.databaseOptions?.table) {
-
-          this.clearRequestCacheMetadata(this.databaseOptions.table)
-
-          return this.dbManagerService.clearTable(this.databaseOptions.table);
-
-        }
-        return of(null);
-      })
-  ))
-
-  // --------------------------------------------------------------------------------------------------
-  // CRUD OPERATIONS
-
-  // FETCH RECORDS
-  readonly fetchRecords = (options?: RequestOptions) =>
-    this.effect<any>(() =>
-    of(RequestOptions.adapt(options)).pipe(
-      switchMap(() => {
-
-        this.streamedResponse = []
-        const requestOptions = this.updateRequestOptions(options?.headers)
-        const effectiveParams = this.getEffectiveParams(options?.path)
-        const requestSignature = this.buildRequestSignature('GET', requestOptions, effectiveParams)
-
-        const fetchFromAPI = () => {
-
-          if (this.hasDatabase && this.databaseOptions?.table) {
-            this.setCachedRequestSignature(this.databaseOptions.table, 'GET', requestSignature)
-
-            if (!this.tryBeginInFlightRequest(requestSignature)) {
-              const currentStateData = this.get()?.data
-              if (Array.isArray(currentStateData) && currentStateData.length > 0) {
-                return of(currentStateData)
-              }
-
-              if (
-                currentStateData &&
-                !Array.isArray(currentStateData) &&
-                Object.keys(currentStateData).length > 0
-              ) {
-                return of(currentStateData)
-              }
-
-              return of(this.dataType === DataType.ARRAY ? [] : {})
-            }
-          }
-
-          return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(
-            tap((data: any) => {
-              // Extract array from paginated response if needed
-              const arrayData = (data?.results && Array.isArray(data.results)) ? data.results : data
-              data = (!arrayData) ? (this.dataType === DataType.ARRAY) ? [] : {} : arrayData
-              this.setData$(data)
-            }),
-            concatMap((data: any) => {
-              // Extract array from paginated response for database storage
-              const dbData = (data?.results && Array.isArray(data.results)) ? data.results : data
-              if (this.hasDatabase && this.databaseOptions?.table && Array.isArray(dbData) && dbData.length > 0) {
-                const tableName = this.databaseOptions.table
-
-                const schema = this.buildSchemaFromSample(dbData[0]);
-                const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
-                const schemaSignature = this.buildSchemaSignature(schema)
-
-                // Always ensure table exists immediately before writing to avoid stale schema/store races.
-                return this.localStorageManagerService.store$(tableName).pipe(
-                  take(1),
-                  switchMap((storeData: any) => {
-                    this.localStorageManagerService.updateStore({
-                      name: tableName,
-                      data: { ...(storeData || {}), ...this.databaseOptions, expires: this.utils.expires(this.databaseOptions!.expiresIn) }
-                    })
-
-                    const ensureTable$ = this.dbManagerService.createDatabaseTable(tableDef)
-
-                    return ensureTable$.pipe(
-                      switchMap((created) => {
-                        if (!created) {
-                          console.warn('[DB STORAGE] Table create/open not ready, skipping DB write for this payload:', { table: tableName });
-                          return of(data);
-                        }
-                        return this.dbManagerService.createTableRecords(tableName, dbData).pipe(
-                          tap(() => this.saveRequestCacheMetadata(tableName, 'GET', requestSignature, schemaSignature, options))
-                        );
-                      })
-                    )
-                  }),
-                  catchError((error) => {
-                    console.error('[DB STORAGE] Failed to ensure table and write records:', { table: tableName, schema, error });
-                    return of(data);
-                  })
-                );
-              }
-              return of(data);
-            }),
-            finalize(() => {
-              if (this.hasDatabase && this.databaseOptions?.table) {
-                this.endInFlightRequest(requestSignature)
-              }
-            })
-          );
-
-        }
-
-        // console.log('[DB STORAGE] Checking database storage:', {
-        //   hasDatabase: this.hasDatabase,
-        //   table: this.databaseOptions?.table,
-        //   databaseOptions: this.databaseOptions
-        // })
-
-        if (this.hasDatabase && this.databaseOptions?.table) {
-
-          return this.dbManagerService.databaseExists().pipe(
-            switchMap((dbExists: boolean) => {
-
-              if (!dbExists) {
-                const initObs: Observable<any> = this.initDBStorageAsync();
-                return initObs.pipe(
-                  switchMap(() => fetchFromAPI()),
-                  catchError((error) => {
-                    console.warn('[DB STORAGE] initDBStorageAsync failed when DB did not exist, continuing with API:', error);
-                    return fetchFromAPI();
-                  })
-                );
-              }
-
-              return this.dbManagerService.hasDatabaseTable(this.databaseOptions!.table).pipe(
-                switchMap((tableExists: boolean): Observable<any> => {
-
-                  if (!tableExists) {
-                    const initObs: Observable<any> = this.initDBStorageAsync();
-                    return initObs.pipe(
-                      switchMap(() => fetchFromAPI()),
-                      catchError((error) => {
-                        console.warn('[DB STORAGE] initDBStorageAsync failed when table missing, continuing with API:', error);
-                        return fetchFromAPI();
-                      })
-                    );
-                  }
-
-                  return this.localStorageManagerService.store$(this.databaseOptions!.table).pipe(
-                    take(1),
-                    switchMap((storeData: any) => {
-                      // console.log('[CacheDebug] storeData for table:', this.databaseOptions!.table, { storeData, requestCache: storeData?.requestCache, expires: storeData?.expires })
-
-                      const forceRefresh = !!(options as any)?.forceRefresh
-                      const storedSchemaSignature = this.getStoredSchemaSignature(storeData)
-
-                      const expires = storeData?.expires || 0;
-                      const hasExpired = expires > 0 && this.utils.hasExpired(expires);
-
-                      if (forceRefresh) {
-                        return fetchFromAPI();
-                      }
-
-                      if (hasExpired) {
-                        return this.dbManagerService.clearTable(this.databaseOptions!.table).pipe(
-                          switchMap(() => fetchFromAPI())
-                        );
-                      }
-
-                      const expectedSchema = this.buildSchemaFromAdapter()
-                      const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema)
-                      // console.log('[CacheDebug] schema check:', { tableName: this.databaseOptions!.table, storedSchemaSignature, expectedSchemaSignature, mismatch: storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature })
-                      if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
-                        const tableDef = TableSchemaDef.adapt({ table: this.databaseOptions!.table, schema: expectedSchema })
-                        return this.dbManagerService.clearTable(this.databaseOptions!.table).pipe(
-                          switchMap(() => this.dbManagerService.createDatabaseTable(tableDef)),
-                          switchMap(() => fetchFromAPI())
-                        )
-                      }
-
-                      return this.checkTrackerAllowsRequest(
-                        this.databaseOptions!.table,
-                        'GET',
-                        this.resolvePath(effectiveParams),
-                        options,
-                        storeData
-                      ).pipe(
-                        switchMap((trackerAllowsRequest: boolean) => {
-                          if (trackerAllowsRequest) {
-                            const normalizedPath = this.trackerNormalizePath(this.resolvePath(effectiveParams));
-
-                            if (!normalizedPath.hasQuery) {
-                              return this.dbManagerService.getTableRecords(this.databaseOptions!.table).pipe(
-                                switchMap((dbData: any) => {
-                                    if (Array.isArray(dbData) && dbData.length > 0) {
-                                    this.setData$(dbData);
-                                    // Save cache metadata for both GET and STREAM request types so
-                                    // tracker/check logic can detect cached responses regardless
-                                    // of whether a subsequent call is a normal GET or a streaming GET.
-                                    const getSignature = requestSignature;
-                                    const streamRequestOptions = { ...(requestOptions || {}), stream: true } as any;
-                                    const streamSignature = this.buildRequestSignature('STREAM', streamRequestOptions, effectiveParams);
-                                    this.saveRequestCacheMetadata(
-                                      this.databaseOptions!.table,
-                                      'GET',
-                                      getSignature,
-                                      storedSchemaSignature ?? expectedSchemaSignature ?? undefined,
-                                      options
-                                    );
-                                    this.saveRequestCacheMetadata(
-                                      this.databaseOptions!.table,
-                                      'STREAM',
-                                      streamSignature,
-                                      storedSchemaSignature ?? expectedSchemaSignature ?? undefined,
-                                      options
-                                    );
-                                    return of({ data: dbData, fromCache: true });
-                                  }
-                                  return fetchFromAPI();
-                                }),
-                                catchError((error) => {
-                                  const tableName = this.databaseOptions!.table;
-                                  console.warn('[DB STORAGE] fallback cache read failed, falling back to API:', { table: tableName, error });
-                                  return fetchFromAPI();
-                                })
-                              );
-                            }
-
-                            return fetchFromAPI();
-                          }
-
-                          return this.dbManagerService.getTableRecords(this.databaseOptions!.table).pipe(
-                            switchMap((dbData: any) => {
-
-                              if (Array.isArray(dbData) && dbData.length > 0) {
-                                this.setData$(dbData);
-                                this.saveRequestCacheMetadata(
-                                  this.databaseOptions!.table,
-                                  'GET',
-                                  requestSignature,
-                                  storedSchemaSignature ?? expectedSchemaSignature ?? undefined,
-                                  options
-                                );
-                                return of(dbData);
-                              }
-
-                              return fetchFromAPI();
-
-                            })
-                            ,
-                            catchError((error) => {
-                              const tableName = this.databaseOptions!.table;
-                              console.warn('[DB STORAGE] getTableRecords failed, recreating table and falling back to API:', { table: tableName, error });
-                              const schema = this.buildSchemaFromAdapter();
-                              const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
-                              return this.dbManagerService.createDatabaseTable(tableDef).pipe(
-                                switchMap(() => fetchFromAPI()),
-                                catchError((recreateError) => {
-                                  console.error('[DB STORAGE] Failed to recreate table after read error, continuing with API only:', recreateError);
-                                  return fetchFromAPI();
-                                })
-                              );
-                            })
-                          );
-                        })
-                      );
-                    })
-                  );
-
-                })
-              );
-            })
-          );
-
-        }
-
-        return fetchFromAPI();
-
-      })
-    )
-  )
-
-  private initDBStorageAsync(): Observable<any> {
-
-    console.log('[initDBStorageAsync] Starting initialization:', {
-      dataType: this.dataType,
-      hasAdapter: !!this.apiOptions?.adapter,
-      table: this.databaseOptions?.table,
-      databaseOptions: this.databaseOptions
-    })
-
-    if (this.dataType !== DataType.ARRAY) {
-      console.warn('Database storage requires dataType to be ARRAY');
-      return of(null);
-    }
-
-    if (!this.apiOptions.adapter) {
-      console.warn('Database storage adapter missing, using minimal or inferred schema');
-    }
-
-    if (!this.databaseOptions?.table) {
-      console.warn('Database storage requires a table name');
-      return of(null);
-    }
-
-    const schema = this.buildSchemaFromAdapter();
-
-    const tableDef = TableSchemaDef.adapt({
-      table: this.databaseOptions?.table,
-      schema: schema
-    });
-
-    return this.dbManagerService.createDatabaseTable(tableDef).pipe(
-      tap((created) => {
-        if (created && this.databaseOptions?.table) {
-          this.saveSchemaSignature(this.databaseOptions.table, this.buildSchemaSignature(schema))
-        }
-      })
-    );
-
-  }
-
-  private buildSchemaFromAdapter(): string {
-    const sampleData = this.apiOptions.adapter?.({}) || {};
-    return this.buildSchemaFromSample(sampleData);
-  }
-
-  private buildSchemaFromSample(sampleData: any): string {
-    const schemaKeys = Object.keys(sampleData || {}).filter(key => sampleData[key] !== undefined);
-    let schema = '++id';
-
-    if (schemaKeys.length > 0) {
-      const otherKeys = schemaKeys.filter((k) => k !== 'id').sort();
-      if (otherKeys.length > 0) {
-        schema += ', ' + otherKeys.join(', ');
-      }
-    }
-
-    return schema;
-  }
-
-  private persistStreamDataToDb(payload: any, streamOptions?: RequestOptions): Observable<any> {
-    if (!this.hasDatabase || !this.databaseOptions?.table) {
-      return of(payload);
-    }
-
-    const dbData = (payload?.results && Array.isArray(payload.results))
-      ? payload.results
-      : Array.isArray(payload)
-        ? payload
-        : payload
-          ? [payload]
-          : [];
-
-    if (dbData.length === 0) {
-      return of(payload);
-    }
-
-    const tableName = this.databaseOptions.table;
-    const requestOptions = this.updateRequestOptions(streamOptions?.headers)
-    requestOptions.stream = true
-    const effectiveParams = this.getEffectiveParams(streamOptions?.path)
-    const requestSignature = this.buildRequestSignature('STREAM', requestOptions, effectiveParams)
-
-    const schema = this.buildSchemaFromSample(dbData[0]);
-    const schemaSignature = this.buildSchemaSignature(schema)
-    const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
-
-    return this.localStorageManagerService.store$(tableName).pipe(
-      take(1),
-      switchMap((storeData: any) => {
-        this.localStorageManagerService.updateStore({
-          name: tableName,
-          data: { ...(storeData || {}), ...this.databaseOptions, expires: this.utils.expires(this.databaseOptions!.expiresIn) }
-        });
-
-        const ensureTable$ = this.dbManagerService.createDatabaseTable(tableDef)
-
-        return ensureTable$.pipe(
-          switchMap((created) => {
-            if (!created) {
-              console.warn('[DB STORAGE] Stream table create/open not ready, skipping DB write for this chunk:', { table: tableName });
-              return of(payload);
-            }
-            return this.dbManagerService.createTableRecords(tableName, dbData).pipe(
-              tap(() => this.saveRequestCacheMetadata(tableName, 'STREAM', requestSignature, schemaSignature, streamOptions)),
-              map(() => payload)
-            );
-          })
-        )
-      }),
-      map(() => payload),
-      catchError((error) => {
-        console.error('[DB STORAGE] Failed to persist streaming payload:', { table: tableName, schema, error });
-        return of(payload);
-      })
-    );
-  }
-
-  // FETCH RECORD
-  readonly fetchRecord = (options: RequestOptions, method: string) =>
-    this.effect<any>(() =>
-    of(RequestOptions.adapt(options)).pipe(
-      tap(() => console.log('🔄 fetchRecord effect triggered with path:', options?.path, 'method:', method)),
-      switchMap((options) => {
-
-        this.streamedResponse = []
-
-        // Temporarily update apiOptions.path with the path from the WebSocket message
-        // This ensures the request goes to the correct endpoint
-        const originalPath = this.apiOptions.path;
-        if (options?.path && Array.isArray(options.path)) {
-          this.apiOptions.path = options.path;
-          console.log('🔧 Temporarily set apiOptions.path to:', options.path);
-        }
-
-        const requestOptions = this.updateRequestOptions(options?.headers)
-
-        console.log('🌐 Making GET request to path:', this.apiOptions.path)
-        return this.httpManagerService.getRequest(requestOptions)
-        .pipe(
-          tap((data: any) => {
-            console.log('📦 fetchRecord received data:', data)
-
-            // Restore original path after request completes
-            this.apiOptions.path = originalPath;
-            console.log('🔧 Restored apiOptions.path to:', originalPath);
-
-            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
-
-            const id = (options as any).path?.length ? options.path[options.path.length -1] : null
-
-            if(method === 'DELETE') {
-              console.log('🗑️ Deleting record with id:', id)
-              this.deleteData$({ id } as T & { id: number })
-            }
-            if(method === 'UPDATE') {
-              console.log('✏️ Updating record:', data)
-              this.updateData$(data)
-            }
-            if(method === 'CREATE') {
-              console.log('➕ Adding record:', data)
-              this.addData$(data)
-            }
-
-          }),
-          concatMap((data: any) => {
-            if (this.hasDatabase && this.databaseOptions?.table) {
-              const id = (options as any).path?.length ? options.path[options.path.length -1] : null
-
-              if(method === 'DELETE' && id) return this.dbManagerService.deleteTableRecord(this.databaseOptions.table, id)
-              if(method === 'UPDATE' && data) return this.dbManagerService.updateTableRecord(this.databaseOptions.table, data)
-              if(method === 'CREATE' && data) {
-                // Validate that data has a valid id before saving to IndexedDB
-                if (data && (data.id !== undefined && data.id !== null && data.id !== '')) {
-                  console.log('💾 Saving to IndexedDB:', { table: this.databaseOptions.table, id: data.id, data });
-                  return this.dbManagerService.createTableRecord(this.databaseOptions.table, data);
-                } else {
-                  console.warn('⚠️ Skipping IndexedDB save: data.id is invalid', data);
-                }
-              }
-            }
-            return of(data)
-          })
-        )
-
-      })
-    )
-  )
-
-  // CREATE RECORD
-  readonly createRecord = (data: any|null, options?: RequestOptions) =>
-    this.effect<any>(() =>
-      of(data).pipe(
-        switchMap((data: any) => {
-
-        this.streamedResponse = []
-        const requestOptions = this.updateRequestOptions(options?.headers)
-
-        return this.httpManagerService.postRequest(data, requestOptions, options?.path)
-        .pipe(
-          tap((data: any) => {
-            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
-            this.addData$(data)
-            this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'CREATE' }))
-            // Always call wsCommunication - it will queue if not connected
-            this.wsCommunication('CREATE', [...options?.path || [], data.id])
-          }),
-          concatMap((data: any) => {
-            if (this.hasDatabase && this.databaseOptions?.table && data?.id) {
-              return this.dbManagerService.createTableRecord(this.databaseOptions.table, data);
-            }
-            return of(data);
-          })
-        )
-
-      })
-    )
-  )
-
-  // UPDATE RECORD
-  readonly updateRecord = (data: any|null, options?: RequestOptions) =>
-    this.effect<any>(() =>
-    of(data).pipe(
-      concatMap((data: any) => {
-
-        this.streamedResponse = []
-        const requestOptions = this.updateRequestOptions(options?.headers)
-
-        return this.httpManagerService.putRequest(data, requestOptions, options?.path)
-        .pipe(
-          tap((data: any) => {
-            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
-            this.updateData$(data)
-            this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'UPDATE' }))
-            // Always call wsCommunication - it will queue if not connected
-            this.wsCommunication('UPDATE', [...options?.path || []])
-          }),
-          concatMap((data: any) => {
-            if (this.hasDatabase && this.databaseOptions?.table && data?.id) {
-              return this.dbManagerService.updateTableRecord(this.databaseOptions.table, data);
-            }
-            return of(data);
-          })
-        )
-
-      })
-    )
-  )
-
-  // DELETE RECORD
-  readonly deleteRecord = (options?: RequestOptions) =>
-    this.effect<any>(() =>
-    of(options).pipe(
-      concatMap((data: any) => {
-
-        this.streamedResponse = []
-        const requestOptions = this.updateRequestOptions(options?.headers)
-
-        return this.httpManagerService.deleteRequest(requestOptions, options?.path)
-        .pipe(
-          tap((data: any) => {
-            data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
-            this.deleteData$(data)
-            this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'DELETE' }))
-            // Always call wsCommunication - it will queue if not connected
-            this.wsCommunication('DELETE', [...options?.path || []])
-          }),
-          concatMap((data: any) => {
-            if (this.hasDatabase && this.databaseOptions?.table && data?.id) {
-              return this.dbManagerService.deleteTableRecord(this.databaseOptions.table, data.id);
-            }
-            return of(data);
-          })
-        )
-
-      })
-    )
-  )
-
-  // --------------------------------------------------------------------------------------------------
-  // FETCH STREAM
-  readonly createStream = (data: any|null, options?: RequestOptions) =>
-    this.effect<any>(() =>
-    of(data).pipe(
-      tap(() => this.httpManagerService.isPending.next(true)),
-      switchMap((data: any) => {
-
-        const requestOptions = this.updateRequestOptions(options?.headers)
-
-        return this.httpManagerService.postRequest(data, requestOptions, options?.path)
-        .pipe(
-          tap((res: any) => {
-            if(res.length > 0) this.setData$(res)
-            this.streamedResponse = res
-          }),
-          concatMap((res: any) => this.persistStreamDataToDb(res, options)),
-          scan((acc, res: any) => {
-
-            const previous = acc.current
-            const current = res
-            return { previous, current };
-
-          }, { previous: null, current: null }),
-          tap(({ previous, current }) => {
-
-            if(previous && JSON.stringify(previous) === JSON.stringify(current)) {
-              this.httpManagerService.isPending.next(false)
-              this.setData$([])
-            } else {
-              this.httpManagerService.isPending.next(true)
-            }
-
-          })
-        )
-
-      })
-    )
-
-  )
-
-  readonly fetchStream = (options?: RequestOptions) =>
-    this.effect<any>(() =>
-    of(options).pipe(
-      tap(() => {
-        // console.log('[DEBUG] fetchStream called')
-        this.streamedResponse = []
-        this.httpManagerService.isPending.next(true)
-      }),
-      switchMap((options: any) => {
-
-        const requestOptions = this.updateRequestOptions(options?.headers)
-        requestOptions.stream = true
-        const effectiveParams = this.getEffectiveParams(options?.path)
-
-        // console.log('[DEBUG] Making streaming request:', requestOptions)
-
-        if (this.hasDatabase && this.databaseOptions?.table) {
-          const requestSignature = this.buildRequestSignature('STREAM', requestOptions, effectiveParams)
-          const fetchStreamFromAPI = () => {
-            if (!this.tryBeginInFlightRequest(requestSignature)) {
-              const currentStateData = this.get()?.data
-              if (Array.isArray(currentStateData) && currentStateData.length > 0) {
-                return of({ data: currentStateData, fromCache: true })
-              }
-
-              if (
-                currentStateData &&
-                !Array.isArray(currentStateData) &&
-                Object.keys(currentStateData).length > 0
-              ) {
-                return of({ data: currentStateData, fromCache: true })
-              }
-
-              return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true })
-            }
-
-            this.setCachedRequestSignature(this.databaseOptions!.table, 'STREAM', requestSignature)
-            return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(
-              map((apiData: any) => ({ data: apiData, fromCache: false })),
-              finalize(() => this.endInFlightRequest(requestSignature))
-            )
-          }
-
-          return this.localStorageManagerService.store$(this.databaseOptions.table).pipe(
-            take(1),
-            switchMap((storeData: any) => {
-              const forceRefresh = !!(options as any)?.forceRefresh
-              const expires = storeData?.expires || 0
-              const hasExpired = expires > 0 && this.utils.hasExpired(expires)
-
-              if (forceRefresh) {
-                return fetchStreamFromAPI()
-              }
-
-              if (hasExpired) {
-                return this.dbManagerService.clearTable(this.databaseOptions!.table).pipe(
-                  switchMap(() => fetchStreamFromAPI())
-                )
-              }
-
-              const storedSchemaSignature = this.getStoredSchemaSignature(storeData)
-              const expectedSchema = this.buildSchemaFromAdapter()
-              const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema)
-              if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
-                const tableDef = TableSchemaDef.adapt({ table: this.databaseOptions!.table, schema: expectedSchema })
-                return this.dbManagerService.clearTable(this.databaseOptions!.table).pipe(
-                  switchMap(() => this.dbManagerService.createDatabaseTable(tableDef)),
-                  switchMap(() => fetchStreamFromAPI())
-                )
-              }
-
-              return this.checkTrackerAllowsRequest(
-                this.databaseOptions!.table,
-                'STREAM',
-                this.resolvePath(effectiveParams),
-                options,
-                storeData
-              ).pipe(
-                switchMap((trackerAllowsRequest: boolean) => {
-                  if (!trackerAllowsRequest) {
-                    return this.dbManagerService.getTableRecords(this.databaseOptions!.table).pipe(
-                      switchMap((dbData: any) => {
-                        if (Array.isArray(dbData) && dbData.length > 0) {
-                          return of({ data: dbData, fromCache: true })
-                        }
-
-                        const currentStateData = this.get()?.data
-                        if (Array.isArray(currentStateData) && currentStateData.length > 0) {
-                          return of({ data: currentStateData, fromCache: true })
-                        }
-
-                        if (
-                          currentStateData &&
-                          !Array.isArray(currentStateData) &&
-                          Object.keys(currentStateData).length > 0
-                          ) {
-                            return of({ data: currentStateData, fromCache: true })
-                          }
-
-                          return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true })
-                        })
-                    )
-                  }
-
-                  return fetchStreamFromAPI()
-                })
-              )
-            })
-          ).pipe(
-            tap((packet: any) => {
-              const res = packet?.data
-              // console.log('[DEBUG] Streaming response received:', res)
-
-              if (res && res.length > 0) {
-                // console.log('[DEBUG] Updating state with streaming data:', res)
-                this.setData$(res)
-                this.streamedResponse = [...this.streamedResponse, ...res]
-              }
-            }),
-            concatMap((packet: any) => {
-              if (packet?.fromCache) {
-                return of(packet?.data)
-              }
-              return this.persistStreamDataToDb(packet?.data, options)
-            }),
-            map((res: any) => {
-              // console.log('[DEBUG] Returning data to subscribers:', res)
-              return res
-            }),
-            catchError((error) => {
-              console.error('[DEBUG] Streaming error:', error)
-              return of([])
-            }),
-            finalize(() => this.httpManagerService.isPending.next(false))
-          )
-        }
-
-        // If no database is configured, always call the API (do not check tracker)
-        return this.httpManagerService.getRequest(requestOptions, effectiveParams)
-        .pipe(
-          tap((res: any) => {
-            console.log('[DEBUG] Streaming response received:', res)
-
-            // Always update state with streaming data
-            if (res && res.length > 0) {
-              // console.log('[DEBUG] Updating state with streaming data:', res)
-              this.setData$(res)
-              this.streamedResponse = [...this.streamedResponse, ...res]
-            } else {
-              // console.log('[DEBUG] No streaming data or empty array:', res)
-            }
-          }),
-          concatMap((res: any) => this.persistStreamDataToDb(res, options)),
-          map((res: any) => {
-            // console.log('[DEBUG] Returning data to subscribers:', res)
-            return res // Return the data so subscribers can receive it
-          }),
-          catchError((error) => {
-            // console.error('[DEBUG] Streaming error:', error)
-            return of([])
-          }),
-          finalize(() => this.httpManagerService.isPending.next(false))
-        )
-
-      }),
-    )
-  )
-
-  // WEBSOCKET COMMUNICATION (STATE MANAGER)
-  private wsCommunication(method: string, path?: string|number[]) {
-    if (!this.apiOptions.ws) {
-      console.warn('wsCommunication called but no WebSocket options configured');
-      return;
-    }
-
-    // If connected, send immediately (check singleton WebSocketManagerService)
-    if (WebSocketManagerService.isConnected()) {
-      this.sendWsCommunication(method, path);
-    } else {
-      // Queue the message to be sent when connection is established
-      console.log(`⏳ Queuing WS message (not connected): ${method} ${path ? JSON.stringify(path) : ''}`);
-      HTTPManagerStateService.wsCommunicationQueue.push({ method, path });
-    }
-  }
-
-  /**
-   * Actually send the WebSocket message (called when connected or from queue)
-   */
-  private sendWsCommunication(method: string, path?: string|number[]) {
-    if (this.apiOptions.ws) {
-      const wsServer = this.apiOptions.ws.id;
-
-      // Guard: Don't send if channel is empty
-      if (!wsServer || wsServer === '') {
-        console.error('❌ Cannot send WS message: Channel ID is empty!');
-        return;
-      }
-
-      // DEBUG: Log what we're sending
-      console.log('🔍 [DEBUG] sendWsCommunication called:', {
-        wsServer,
-        wsServerType: typeof wsServer,
-        wsServerEmpty: wsServer === '' || wsServer === null || wsServer === undefined,
-        method,
-        path,
-        user: this.apiOptions.ws.user,
-        fullPayload: { method, path, user: this.apiOptions.ws.user }
-      });
-
-      this.httpManagerService.sendMessageInChannel(wsServer, { method, path, user: this.apiOptions.ws.user });
-    } else {
-      console.error('❌ [DEBUG] sendWsCommunication: apiOptions.ws is undefined!');
-    }
-  }
-
-  /**
-   * Send a message to channel(s)
-   * @param message - The message content
-   * @param channels - Optional array of channel names (passed as-is, caller should include prefix)
-   *                   Use 'allChannels' to broadcast to all
-   */
-  wsMessaging(message: ChannelMessage, channels?: string[]) {
-
-    const user = this.user.value
-    const messageInfo = ChannelMessage.adapt({ ...message, fromUser: user })
-
-    console.log('📤 wsMessaging called with channels:', channels);
-
-    if (WebSocketManagerService.isConnected() && this.apiOptions.ws) {
-
-      // If specific channels provided, send to each channel
-      // Channels are passed as-is - caller is responsible for including the correct prefix
-      if (channels && channels.length > 0) {
-        console.log(`📤 Sending to ${channels.length} channel(s):`, channels);
-
-        // Send single message with all channels (more efficient)
-        const user = this.user.value;
-        const messageData = {
-          sessionId: user,
-          content: messageInfo
-        };
-
-        this.httpManagerService.sendChannelMessageToChannels(channels, messageData);
-      } else {
-        // Fallback to the primary WS channel (already prefixed with SYS-)
-        const wsChannel = this.apiOptions.ws.id;
-        console.log(`📤 Sending to state channel:`, wsChannel);
-        this.httpManagerService.sendChannelMessage(wsChannel, messageInfo);
-      }
-
-    }
-
-  }
-
-  /**
-   * Subscribe to a messaging channel
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  subscribeToMessageChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
-      this.httpManagerService.subscribeToChannel(prefixedChannel);
-      console.log(`💬 Subscribed to message channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot subscribe to message channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Unsubscribe from a messaging channel
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  unsubscribeFromMessageChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
-      this.httpManagerService.unsubscribeFromChannel(prefixedChannel);
-      console.log(`💬 Unsubscribed from message channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot unsubscribe from message channel: WebSocket not connected.');
-    }
-  }
-
-  // --------------------------------------------------------------------------------------------------
-  // CHANNEL MANAGEMENT (Raw channels - no automatic prefix)
-
-  /**
-   * Subscribe to a single channel (no automatic prefix)
-   * Use subscribeToMessageChannel() for MES- prefixed channels
-   */
-  subscribeToChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      // Get current user data to send with subscription
-      const currentUser = this.user.value;
-      console.log('👤 Subscribing with user:', currentUser)
-      this.httpManagerService.subscribeToChannel(channel, currentUser);
-    } else {
-      console.warn('Cannot subscribe: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Subscribe to multiple channels at once
-   */
-  subscribeToChannels(channels: string[]) {
-    if (WebSocketManagerService.isConnected()) {
-      // Get current user data to send with subscription
-      const currentUser = this.user.value;
-      console.log('👤 Subscribing to', channels.length, 'channels with user:', currentUser)
-      this.httpManagerService.subscribeToChannels(channels, currentUser);
-    } else {
-      console.warn('Cannot subscribe: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Unsubscribe from a channel
-   */
-  unsubscribeFromChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.unsubscribeFromChannel(channel);
-    } else {
-      console.warn('Cannot unsubscribe: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Get observable of currently subscribed channels
-   */
-  get subscribedChannels$(): Observable<Set<string>> {
-    return this.httpManagerService.subscribedChannels$;
-  }
-
-  /**
-   * Get current subscribed channels synchronously
-   */
-  getSubscribedChannels(): Set<string> {
-    return this.httpManagerService.getSubscribedChannels();
-  }
-
-  /**
-   * Create a new channel on the server
-   */
-  createChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.createChannel(channel);
-    } else {
-      console.warn('Cannot create channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Delete a channel from the server
-   */
-  deleteChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.deleteChannel(channel);
-    } else {
-      console.warn('Cannot delete channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Request list of all channels from server
-   */
-  getAllChannels() {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.getAllChannels();
-    } else {
-      console.warn('Cannot get channels: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Get users in a specific channel
-   */
-  getUsersInChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.getUsersInChannel(channel);
-    } else {
-      console.warn('Cannot get users: WebSocket not connected.');
-    }
-  }
-
-  // --------------------------------------------------------------------------------------------------
-  // NOTIFICATION CHANNELS (MES- prefix - managed automatically)
-
-  /**
-   * Create a notification channel on the server
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  createNotificationChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
-      this.httpManagerService.createNotificationChannel(prefixedChannel);
-      console.log(`📢 Creating notification channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot create notification channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Request list of all notification channels from server (in-memory)
-   */
-  getNotificationChannels() {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.getNotificationChannels();
-    } else {
-      console.warn('Cannot get notification channels: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Request list of today's notification channels from database
-   * Returns unique channels that have notifications posted today
-   */
-  getTodaysNotificationChannels() {
-    if (WebSocketManagerService.isConnected()) {
-      this.httpManagerService.getTodaysNotificationChannels();
-    } else {
-      console.warn('Cannot get today\'s notification channels: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Subscribe to a notification channel with optional date filters
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  subscribeToNotificationChannel(channel: string, options?: { startEpoch?: number; endEpoch?: number }, user?: any) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
-      this.httpManagerService.subscribeToNotificationChannel(prefixedChannel, options, user);
-      console.log(`📢 Subscribing to notification channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot subscribe to notification channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Unsubscribe from a notification channel
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  unsubscribeFromNotificationChannel(channel: string) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
-      this.httpManagerService.unsubscribeFromNotificationChannel(prefixedChannel);
-      console.log(`📢 Unsubscribing from notification channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot unsubscribe from notification channel: WebSocket not connected.');
-    }
-  }
-
-  /**
-   * Send a notification to a channel
-   * @param channel - Base channel name (MES- prefix added automatically)
-   */
-  sendNotification(channel: string, content: any) {
-    if (WebSocketManagerService.isConnected()) {
-      const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
-      this.httpManagerService.sendNotification(prefixedChannel, content);
-      console.log(`📢 Sending notification to channel: ${prefixedChannel}`);
-    } else {
-      console.warn('Cannot send notification: WebSocket not connected.');
-    }
-  }
-
-  // --------------------------------------------------------------------------------------------------
-  // MISC
-
-  /**
-   * Clear/flush all records from the database table
-   * Does not clear localStorage metadata (expires info)
-   * Does not re-fetch from API - leaves state empty for manual refresh
-   */
-  clearDatabase() {
-
-    if (!this.hasDatabase || !this.databaseOptions?.table) return;
-
-    const tableName = this.databaseOptions.table;
-
-    // Reset localStorage tracking SYNCHRONOUSLY before the async DB clear so any
-    // concurrent request that fires during clearTable() sees a clean store immediately
-    // and is not blocked by stale queryParams from the previous session.
-    this.localStorageManagerService.updateStore({
-      name: tableName,
-      data: { ...this.databaseOptions, expires: 0 }
-    });
-    this._requestCachePaths.delete(tableName);
-
-    this.dbManagerService.clearTable(tableName).subscribe({
-      next: () => {
-        if (this.dataType === DataType.ARRAY) {
-          this.setData$([]);
-        } else {
-          this.setData$({});
-        }
-      },
-      error: (err) => {
-        console.error(`❌ Error clearing table ${tableName}:`, err);
-      }
-    });
-  }
-
-  private isEmpty(obj: any) {
-    return Object.keys(obj).length === 0
-  }
-
-  private updateRequestOptions(headers?: any): ApiRequest {
-
-    const options = ApiRequest.adapt({ ...this.apiOptions })
-
-    options.headers = (headers)
-          ? { ...options.headers, ...headers }
-          : { ...options.headers }
-
-    return options
-  }
-
-  private normalizeObject(value: any): any {
-    if (Array.isArray(value)) {
-      return value.map((item) => this.normalizeObject(item))
-    }
-
-    if (value && typeof value === 'object') {
-      return Object.keys(value)
-        .sort()
-        .reduce((acc: any, key: string) => {
-          acc[key] = this.normalizeObject(value[key])
-          return acc
-        }, {})
-    }
-
-    return value
-  }
-
-  private filterHeaders(headers?: any): Record<string, any> {
-    const source = headers || {}
-    return Object.keys(source).reduce((acc: Record<string, any>, key: string) => {
-      if (!this.volatileHeaders.has(key.toLowerCase())) {
-        acc[key] = source[key]
-      }
-      return acc
-    }, {})
-  }
-
-  private resolvePath(params?: any[]): any[] {
-    const basePath = Array.isArray(this.apiOptions.path) ? this.apiOptions.path : []
-    const effective = this.getEffectiveParams(params)
-    return effective ? [...basePath, ...effective] : [...basePath]
-  }
-
-  private getEffectiveParams(params?: any[]): any[] | undefined {
-    if (!Array.isArray(params) || params.length === 0) {
-      return undefined
-    }
-
-    const basePath = Array.isArray(this.apiOptions.path) ? this.apiOptions.path : []
-
-    if (basePath.length !== params.length) {
-      return params
-    }
-
-    const normalizePart = (value: any): string => {
-      if (value && typeof value === 'object') {
-        return JSON.stringify(this.normalizeObject(value))
-      }
-      return String(value)
-    }
-
-    const samePath = params.every((part, index) => normalizePart(part) === normalizePart(basePath[index]))
-    return samePath ? undefined : params
-  }
-
-  private buildRequestSignature(method: 'GET'|'STREAM', requestOptions: ApiRequest, params?: any[]): string {
-    const signaturePayload = {
-      method,
-      server: requestOptions.server,
-      path: this.resolvePath(params),
-      headers: this.filterHeaders(requestOptions.headers),
-      stream: !!requestOptions.stream,
-      streamType: requestOptions.streamType || null
-    }
-
-    return JSON.stringify(this.normalizeObject(signaturePayload))
-  }
-
-  private buildSchemaSignature(schema: string): string {
-    return JSON.stringify(this.normalizeObject(schema.split(',').map((part) => part.trim()).filter(Boolean)))
-  }
-
-  private setCachedRequestSignature(tableName: string, type: 'GET'|'STREAM', signature: string): void {
-    const existing = this.requestSignatureCache[tableName] || {}
-    this.requestSignatureCache[tableName] = {
-      ...existing,
-      [type]: signature,
-    }
-  }
-
-  private tryBeginInFlightRequest(signature: string): boolean {
-    if (this.inFlightRequestSignatures.has(signature)) {
-      return false
-    }
-    this.inFlightRequestSignatures.add(signature)
-    return true
-  }
-
-  private endInFlightRequest(signature: string): void {
-    this.inFlightRequestSignatures.delete(signature)
-  }
-
-  private getRequestCacheMetadata(storeData: any, type: 'GET'|'STREAM'): any {
-    return storeData?.requestCache?.[type] || null
-  }
-
-  private getStoredSchemaSignature(storeData: any): string | null {
-    return storeData?.schemaSignature || null
-  }
-
-  private saveSchemaSignature(tableName: string, schemaSignature: string) {
-    this.localStorageManagerService.store$(tableName).pipe(
-      take(1),
-      tap((storeData: any) => {
-        this.localStorageManagerService.updateStore({
-          name: tableName,
-          data: {
-            ...(storeData || {}),
-            schemaSignature,
-          }
-        })
-      })
-    ).subscribe()
-  }
-
-  private saveRequestCacheMetadata(tableName: string, type: 'GET'|'STREAM', signature: string, schemaSignature?: string, options?: RequestOptions) {
-    this.setCachedRequestSignature(tableName, type, signature)
-    this._requestCachePaths.set(tableName, this.resolvePath(options?.path).filter(p => typeof p === 'string' || typeof p === 'number').map(String))
-
-    this.localStorageManagerService.store$(tableName).pipe(
-      take(1),
-      tap((storeData: any) => {
-        const currentCache = storeData?.requestCache || {}
-        const currentEntry = currentCache[type] || {}
-        this.localStorageManagerService.updateStore({
-          name: tableName,
-          data: {
-            ...(storeData || {}),
-            requestCache: {
-              ...currentCache,
-              [type]: {
-                ...currentEntry,
-                signature,
-                savedAt: Date.now(),
-                path: this.resolvePath(options?.path),
-                headers: this.filterHeaders(options?.headers),
-                queryParams: currentEntry.queryParams,
-                queryParamsExpires: currentEntry.queryParamsExpires,
-              }
-            }
-          }
-        })
-      })
-    ).subscribe()
-  }
-
-  private clearRequestCacheMetadata(tableName: string) {
-    this.localStorageManagerService.store$(tableName).pipe(
-      take(1),
-      tap((storeData: any) => {
-        let pathArray = this._requestCachePaths.get(tableName)
-        if (!Array.isArray(pathArray) || pathArray.length === 0) {
-          const requestCache = storeData?.requestCache
-          if (requestCache) {
-            const cached = requestCache['GET'] || requestCache['STREAM']
-            if (Array.isArray(cached?.path) && cached.path.length > 0) {
-              pathArray = cached.path.filter((p: any) => typeof p === 'string' || typeof p === 'number').map(String)
-            }
-          }
-        }
-        if (Array.isArray(pathArray) && pathArray.length > 0) {
-          // this.queryParamsTrackerService.clearTrackingForPath(pathArray.join('/'))
-          this._requestCachePaths.delete(tableName)
-        }
-        if (!storeData) return
-        const updated = { ...(storeData || {}) }
-        delete updated.requestCache
-        delete updated.tracker
-        this.localStorageManagerService.updateStore({
-          name: tableName,
-          data: updated
-        })
-      })
-    ).subscribe()
-  }
-
-  private trackerNormalizePath(path: any[]): { pathKey: string; query: Record<string, string>; hasQuery: boolean } {
-    const pathSegments: string[] = []
-    const query: Record<string, string> = {}
-    path.forEach((segment) => {
-      if (segment && typeof segment === 'object' && !Array.isArray(segment)) {
-        Object.keys(segment).forEach((key) => {
-          query[this.trackerNormalizeParamKey(key)] = this.trackerNormalizeParamValue(segment[key])
-        })
-      } else {
-        const parsed = this.trackerParsePathSegment(String(segment))
-        pathSegments.push(parsed.pathSegment)
-        Object.keys(parsed.queryObject).forEach((key) => {
-          query[this.trackerNormalizeParamKey(key)] = this.trackerNormalizeParamValue(parsed.queryObject[key])
-        })
-      }
-    })
-    return {
-      pathKey: this.trackerNormalizePathSegments(pathSegments),
-      query,
-      hasQuery: Object.keys(query).length > 0,
-    }
-  }
-
-  private trackerParsePathSegment(rawSegment: string): { pathSegment: string; queryObject: Record<string, any> } {
-    const [pathPart, ...queryParts] = String(rawSegment).split('?')
-    const queryString = queryParts.join('?')
-    const queryObject: Record<string, any> = {}
-    if (queryString) {
-      queryString.split('&').forEach((pair) => {
-        if (!pair) return
-        const [rawKey, ...rawValueParts] = pair.split('=')
-        const key = this.trackerSafeDecode(rawKey).trim()
-        const value = this.trackerSafeDecode(rawValueParts.join('=')).trim()
-        if (!key) return
-        queryObject[key] = value
-      })
-    }
-    return { pathSegment: pathPart, queryObject }
-  }
-
-  private trackerSafeDecode(value: string | undefined): string {
-    if (typeof value === 'undefined') return ''
-    try { return decodeURIComponent(value) } catch { return String(value) }
-  }
-
-  private trackerNormalizePathSegments(pathSegments: string[]): string {
-    return pathSegments
-      .map((segment) => String(segment).trim())
-      .filter((segment) => segment.length > 0)
-      .join('/')
-      .replace(/([^:]\/+)\/+/g, '$1')
-      .replace(/^\//, '')
-      .replace(/\/$/, '')
-  }
-
-  private trackerNormalizeParamKey(key: string): string {
-    return String(key).trim().toLowerCase()
-  }
-
-  private trackerNormalizeParamValue(value: any): string {
-    if (Array.isArray(value)) {
-      return value.map((item) => this.trackerNormalizeParamValue(item)).join(',')
-    }
-    if (Object.prototype.toString.call(value) === '[object Object]') {
-      return JSON.stringify(
-        Object.keys(value).sort().reduce((acc: any, k) => {
-          acc[this.trackerNormalizeParamKey(k)] = this.trackerNormalizeParamValue(value[k])
-          return acc
-        }, {})
-      )
-    }
-    return String(value).trim().toLowerCase()
-  }
-
-  private trackerFilterQuery(query: Record<string, string>, ignoreQueryParams?: string[]): Record<string, string> {
-    if (!Array.isArray(ignoreQueryParams) || ignoreQueryParams.length === 0) return { ...query }
-    const normalizedIgnore = ignoreQueryParams.map(p => this.trackerNormalizeParamKey(p))
-    const result: Record<string, string> = {}
-    Object.keys(query).forEach((key) => {
-      if (!normalizedIgnore.includes(key)) {
-        result[key] = query[key]
-      }
-    })
-    return result
-  }
-
-  private trackerBuildExpiryEpoch(expireIn?: string | number): number | null {
-    if (typeof expireIn === 'undefined' || expireIn === null || expireIn === '') return null
-    if (typeof expireIn === 'number' && Number.isFinite(expireIn) && expireIn > 0) {
-      return Math.floor(Date.now() / 1000) + Math.floor(expireIn)
-    }
-    const raw = String(expireIn).trim().toLowerCase().replace(/\s+/g, '')
-    const parsed = raw.match(/^(\d+)(y|w|d|hr|h|mn|min|m|s)$/)
-    if (!parsed) return null
-    const toSeconds: Record<string, number> = { y: 31556926, w: 604800, d: 86400, hr: 3600, h: 3600, mn: 60, min: 60, m: 60, s: 1 }
-    const seconds = toSeconds[parsed[2]]
-    if (!seconds) return null
-    return Math.floor(Date.now() / 1000) + Number(parsed[1]) * seconds
-  }
-
-  private checkTrackerAllowsRequest(tableName: string, type: 'GET'|'STREAM', path: any[], options: RequestOptions | undefined, storeData: any): Observable<boolean> {
-    const normalized = this.trackerNormalizePath(path)
-    const ignoreQueryParams = Array.isArray(options?.ignoreQueryParams) ? options!.ignoreQueryParams : []
-
-    if (!normalized.hasQuery) {
-      const meta = this.getRequestCacheMetadata(storeData, type)
-      if (!meta) {
-        // No prior cache entry — record that we're tracking this request
-        this.setCachedRequestSignature(tableName, type, '')
-        this.localStorageManagerService.store$(tableName).pipe(
-          take(1),
-          tap((s: any) => {
-            const currentCache = s?.requestCache || {}
-            this.localStorageManagerService.updateStore({
-              name: tableName,
-              data: {
-                ...(s || {}),
-                requestCache: {
-                  ...currentCache,
-                  [type]: {
-                    ...(currentCache[type] || {}),
-                    active: true,
-                  }
-                }
-              }
-            })
-          })
-        ).subscribe()
-      }
-      return of(!meta)
-    }
-
-    const filtered = this.trackerFilterQuery(normalized.query, ignoreQueryParams)
-    const keys = Object.keys(filtered)
-
-    if (keys.length === 0) {
-      // All query params were filtered out — check if we have any prior entry
-      const meta = this.getRequestCacheMetadata(storeData, type)
-      if (!meta) {
-        this.setCachedRequestSignature(tableName, type, '')
-        this.localStorageManagerService.store$(tableName).pipe(
-          take(1),
-          tap((s: any) => {
-            const currentCache = s?.requestCache || {}
-            this.localStorageManagerService.updateStore({
-              name: tableName,
-              data: {
-                ...(s || {}),
-                requestCache: {
-                  ...currentCache,
-                  [type]: {
-                    ...(currentCache[type] || {}),
-                    active: true,
-                  }
-                }
-              }
-            })
-          })
-        ).subscribe()
-      }
-      return of(!meta)
-    }
-
-    const meta = this.getRequestCacheMetadata(storeData, type) || {}
-    const now = Math.floor(Date.now() / 1000)
-    let queryParams: Record<string, string[]> = { ...(meta.queryParams || {}) }
-    let queryParamsExpires: number | null = meta.queryParamsExpires ?? null
-
-    if (queryParamsExpires !== null && queryParamsExpires <= now) {
-      queryParams = {}
-      queryParamsExpires = null
-    }
-
-    let accepted = false
-    keys.forEach(key => {
-      const value = filtered[key]
-      const consumed = queryParams[key] || []
-      if (!consumed.includes(value)) {
-        queryParams[key] = [...consumed, value]
-        accepted = true
-      }
-    })
-
-    if (accepted) {
-      const newExpiry = this.trackerBuildExpiryEpoch(options?.queryParamsExpiresIn)
-      if (newExpiry !== null) {
-        queryParamsExpires = newExpiry
-      }
-      this.localStorageManagerService.store$(tableName).pipe(
-        take(1),
-        tap((latestStoreData: any) => {
-          const currentCache = latestStoreData?.requestCache || {}
-          const currentEntry = currentCache[type] || {}
-          this.localStorageManagerService.updateStore({
-            name: tableName,
-            data: {
-              ...(latestStoreData || {}),
-              requestCache: {
-                ...currentCache,
-                [type]: {
-                  ...currentEntry,
-                  queryParams,
-                  queryParamsExpires,
-                }
-              }
-            }
-          })
-        })
-      ).subscribe()
-    }
-
-    return of(accepted)
-  }
-
-}