http-request-manager 18.7.19 → 18.7.21

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

@@ -0,0 +1,1321 @@
+import { inject, Inject, Injectable, InjectionToken } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+
+import { BehaviorSubject, Observable, of, Subject, timer, merge } from 'rxjs';
+import { tap, switchMap, concatMap, scan, delay, take, map, distinctUntilChanged, takeUntil, takeWhile, filter, catchError } from 'rxjs/operators';
+import { DatabaseStorage } from '../../models/database-storage.model';
+import { ApiRequest, RequestOptions, WSOptions } 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';
+
+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)
+
+  error$ = this.httpManagerService.error$
+  isPending$ = this.httpManagerService.isPending$.pipe(delay(1))
+
+  // 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 = []
+
+  // WS
+  private maxRetries: number
+  private retryDelay: number
+  private shouldRetry = true
+
+  private databaseOptions?: DatabaseStorage
+
+  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) || [])
+    )
+  }
+
+  // Legacy support - 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()
+
+  wsConnection = false
+  wsOptions = WSOptions.adapt()
+
+  // Expose raw WS connection status directly to UI
+  public connectionStatus$: Observable<boolean> = this.httpManagerService.connectionStatus$
+
+  constructor(
+    @Inject(API_OPTS) private apiOptions = ApiRequest.adapt(),
+    @Inject("dataType") private dataType: DataType | undefined,
+    @Inject("database") private database?: DatabaseStorage | undefined
+  ) {
+
+    super(defaultState);
+
+    this.databaseOptions = database
+    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,
+        })
+      })
+
+      this.initDBStorage()
+
+    }
+
+  }
+
+  /**
+   * 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.apiOptions = ApiRequest.adapt(apiOptions)
+    this.dataType = (dataType) ? dataType : DataType.ARRAY
+
+    // Only update database options if a database parameter is explicitly provided
+    if (database !== undefined) {
+      this.hasDatabase = (database?.table) ? true : false
+      this.databaseOptions = (this.hasDatabase) ? DatabaseStorage.adapt(database) : undefined
+    }
+
+    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);
+      console.log(`🔒 Private state channel: ${this.apiOptions.ws.id}`);
+
+      // Update WebSocket retry settings when options change
+      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 === '') {
+        console.error('WSOptions invalid: wsServer is missing or empty');
+        return;
+      }
+
+      // Setup connection status monitoring (internal subscription to drive retry counters)
+      this.setupConnectionStatus().subscribe();
+
+      // Make initial connection attempt
+      console.log('🔄 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 {
+      console.warn('WSOptions invalid Id: empty')
+    }
+
+  }
+
+  // WebSocket
+  private setupConnectionStatus(): Observable<boolean> {
+    return this.httpManagerService.connectionStatus$.pipe(
+      distinctUntilChanged(),
+      tap(status => {
+        if (status === true) {
+          console.log('🟢 WebSocket connection is open.')
+        } else {
+          console.log('🔴 WebSocket connection is closed.')
+        }
+      }),
+      switchMap(status => {
+
+        if (status === true) {
+          this.shouldRetry = true
+          this.wsRetryAttempts.next(0);
+          this.wsNextRetry.next(0);
+          return of(true);
+        }
+
+        if (!this.shouldRetry) return of(false)
+
+        const countdownEnder$ = new Subject<void>();
+
+        // Immediately reflect upcoming retry delay in seconds on UI
+        const seconds = this.retryDelay / 1000;
+        this.wsNextRetry.next(seconds);
+
+        return timer(0, this.retryDelay)
+        .pipe(
+          take(this.maxRetries),
+          tap(i => {
+
+            const attempt = i + 1;
+            this.wsRetryAttempts.next(attempt);
+            countdownEnder$.next();
+
+            // Validate WS options; abort retries if invalid
+            const hasValidWS = !!(this.apiOptions.ws && this.apiOptions.ws.wsServer && this.apiOptions.ws.wsServer !== '');
+
+            if (!hasValidWS) {
+              this.shouldRetry = false;
+              this.wsNextRetry.next(0);
+              this.wsRetryAttempts.next(0);
+              return; // Skip connect and countdown
+            }
+
+            console.log(`🔄 Retry attempt #${attempt}/${this.maxRetries}`);
+            this.httpManagerService.connect(this.apiOptions.ws as WSOptions, this.apiOptions.ws!.jwtToken || '');
+
+            if (attempt === this.maxRetries) {
+              this.wsNextRetry.next(0)
+              //   console.error(`🚨 FAILED CONNECTION: Tried #${attempt} times`);
+            } else {
+              //   console.log(`⚠️ Retry Attempt #${attempt}: Retrying in ${this.retryDelay / 1000}s`);
+              const seconds = this.retryDelay / 1000;
+
+              timer(0, 1000).pipe(
+                map(tick => seconds - tick),
+                takeWhile(val => val >= 0),
+                takeUntil(countdownEnder$)
+              ).subscribe(remaining => {
+                this.wsNextRetry.next(remaining);
+              })
+
+            }
+
+          }),
+          map(() => false)
+        )
+      })
+    );
+  }
+
+  // WebSocket
+  readonly initWS = this.effect<WSOptions>((wsOptions$) =>
+    wsOptions$.pipe(
+      // tap((wsOptions) => { debugger
+      //   this.wsOptions = wsOptions
+      // }),
+      switchMap((wsOptions) =>
+        merge(
+          this.httpManagerService.connectionStatus$.pipe(
+            tap((isConnected: any) => {
+              this.wsConnection = isConnected
+            })
+          ),
+          this.httpManagerService.messages$.pipe(
+            tap((message: any) => {
+              if (!message) return
+
+              // Add message to messages array
+              const currentMessages = this.messages.value
+              this.messages.next([...currentMessages, message])
+
+              console.log('Received:', message)
+
+              if (message.error === 'JWT_INVALID') {
+                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':
+
+                  console.log('💬 Channels:', message.channels)
+
+                  // this.channelList = message.channels
+
+                  // if (this.channelList.includes(wsOptions.id)) {
+                  //   this.httpManagerService.subscribeToChannel(wsOptions.id)
+                  // } else {
+                  //   this.httpManagerService.createChannel(wsOptions.id)
+                  // }
+
+                  this.channels.next(message.channels)
+
+                  break;
+
+                case 'subscribed':
+                  console.log(`✅ Subscription confirmed: ${message.channel}`)
+                  break;
+
+                case 'unsubscribed':
+                  console.log(`🔓 Unsubscription confirmed: ${message.channel}`)
+                  break;
+
+                case 'info':
+                  // Already subscribed or other info messages
+                  console.log(`ℹ️ Info: ${message.message}`)
+                  break;
+
+                case 'stateMangerMessage':
+                  // Compare sender's session ID with current user's ID
+                  // 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 ID:', stateManagerSenderId, 'Current User ID:', this.user.value?.id);
+                  if(stateManagerSenderId !== this.user.value?.id) {
+                    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');
+                  }
+                  break;
+
+                case 'channelMessage':
+                  // Handle channel-based messages (from sendChannelMessage)
+                  // Structure: { type: 'channelMessage', channels: [...], sessionId: {id, ldap, name, email}, content: {message payload} }
+                  // Skip messages from self
+                  const senderSessionId = message.sessionId?.id;
+                  if (senderSessionId === this.user.value?.id) {
+                    break;
+                  }
+                  console.log('💬 Channel Message received:', message);
+                  if (message.content) {
+                    this.appendMessages(ChannelMessage.adapt({
+                      sessionId: message.sessionId,
+                      content: message.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)
+                  this.notificationChannels.next(message.channels || [])
+                  break;
+
+                case 'todaysNotificationChannelsList':
+                  console.log('📢 Today\'s Notification Channels (from DB):', message.channels)
+                  this.todaysNotificationChannels.next(message.channels || [])
+                  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(() => {
+        if (this.dataType !== DataType.ARRAY) console.warn('Database storage requires dataType to be ARRAY')
+        if (!this.apiOptions.adapter) console.warn('Database storage requires an adapter to define the data shape')
+        if (this.databaseOptions && this.databaseOptions?.table === '') console.warn('Database storage requires a table name')
+      }),
+      filter(() => this.dataType === DataType.ARRAY && !!this.apiOptions.adapter && !!this.databaseOptions?.table),
+      switchMap(() => {
+        const sampleData = this.apiOptions.adapter?.({}) || {}
+        const schemaKeys = Object.keys(sampleData).filter(key => sampleData[key] !== undefined)
+
+        let schema = '++id'
+
+        if (schemaKeys.length > 0) {
+          const otherKeys = schemaKeys.filter(k => k !== 'id')
+          if (otherKeys.length > 0) {
+            schema += ', ' + otherKeys.join(', ')
+          }
+        }
+
+        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[] {
+
+    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) {
+
+          const currentData = this.get()?.data;
+          const idsToDelete = Array.isArray(currentData) ? currentData.map((r: any) => r.id) : [];
+
+          if (idsToDelete.length > 0) {
+            return this.dbManagerService.deleteTableRecords(this.databaseOptions.table, idsToDelete);
+          }
+
+        }
+        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 fetchFromAPI = () => {
+
+          return this.httpManagerService.getRequest(requestOptions, options?.path).pipe(
+            tap((data: any) => {
+              data = (!data) ? (this.dataType === DataType.ARRAY) ? [] : {} : data
+              this.setData$(data)
+            }),
+            concatMap((data: any) => {
+              if (this.hasDatabase && this.databaseOptions?.table && Array.isArray(data) && data.length > 0) {
+
+                this.localStorageManagerService.updateStore({
+                  name: this.databaseOptions!.table,
+                  data: { ...this.databaseOptions, ...{ expires: this.utils.expires(this.databaseOptions!.expiresIn)} }
+                })
+
+                return this.dbManagerService.createTableRecords(this.databaseOptions.table, data);
+              }
+              return of(data);
+            })
+          );
+
+        }
+
+        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())
+                );
+              }
+
+              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())
+                    );
+                  }
+
+                  return this.localStorageManagerService.store$(this.databaseOptions!.table).pipe(
+                    take(1),
+                    switchMap((storeData: any) => {
+
+                      const expires = storeData?.expires || 0;
+                      const hasExpired = expires > 0 && this.utils.hasExpired(expires);
+
+                      if (hasExpired) {
+                        return this.dbManagerService.clearTable(this.databaseOptions!.table).pipe(
+                          switchMap(() => fetchFromAPI()),
+                          tap(() => {
+                            this.localStorageManagerService.updateStore({
+                              name: this.databaseOptions!.table,
+                              data: { ...this.databaseOptions, ...{ expires: this.utils.expires(this.databaseOptions!.expiresIn)} }
+                            })
+                          })
+                        );
+                      }
+
+                      return this.dbManagerService.getTableRecords(this.databaseOptions!.table).pipe(
+                        switchMap((dbData: any) => {
+
+                          if (Array.isArray(dbData) && dbData.length > 0) {
+                            this.setData$(dbData);
+                            return of(dbData);
+                          }
+
+                          return fetchFromAPI();
+
+                        })
+                      );
+                    })
+                  );
+
+                })
+              );
+            })
+          );
+
+        }
+
+        return fetchFromAPI();
+
+      })
+    )
+  )
+
+  private initDBStorageAsync() {
+
+    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 requires an adapter to define the data shape');
+      return of(null);
+    }
+
+    if (!this.databaseOptions?.table) {
+      console.warn('Database storage requires a table name');
+      return of(null);
+    }
+
+    const sampleData = this.apiOptions.adapter?.({}) || {};
+    const schemaKeys = Object.keys(sampleData).filter(key => sampleData[key] !== undefined);
+
+    let schema = '++id';
+
+    if (schemaKeys.length > 0) {
+      const otherKeys = schemaKeys.filter(k => k !== 'id');
+      if (otherKeys.length > 0) {
+        schema += ', ' + otherKeys.join(', ');
+      }
+    }
+
+    const tableDef = TableSchemaDef.adapt({
+      table: this.databaseOptions?.table,
+      schema: schema
+    });
+
+    return this.dbManagerService.createDatabaseTable(tableDef);
+
+  }
+
+  // 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 = []
+        const requestOptions = this.updateRequestOptions(options?.headers)
+
+        console.log('🌐 Making GET request to path:', options?.path)
+        return this.httpManagerService.getRequest(requestOptions, options?.path)
+        .pipe(
+          tap((data: any) => {
+            console.log('📦 fetchRecord received data:', data)
+
+            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) return this.dbManagerService.createTableRecord(this.databaseOptions.table, 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)
+            if(this.wsConnection) 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)
+            if(this.wsConnection) 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)
+            if(this.wsConnection) 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
+          }),
+          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.httpManagerService.isPending.next(true)
+      }),
+      switchMap((options: any) => {
+
+        const requestOptions = this.updateRequestOptions(options?.headers)
+        requestOptions.stream = true
+
+        console.log('[DEBUG] Making streaming request:', requestOptions)
+
+        return this.httpManagerService.getRequest(requestOptions, options?.path)
+        .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 = res
+            } else {
+              console.log('[DEBUG] No streaming data or empty array:', res)
+            }
+          }),
+          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)
+            this.httpManagerService.isPending.next(false)
+            return of([])
+          })
+        )
+
+      }),
+    )
+  )
+
+  // WEBSOCKET COMMUNICATION (STATE MANAGER)
+  private wsCommunication(method: string, path?: string|number[]) {
+    if(this.wsConnection && this.apiOptions.ws) {
+      const wsServer = this.apiOptions.ws.id
+      this.httpManagerService.sendMessageInChannel(wsServer, { method, path, user: this.apiOptions.ws.user })
+    }
+
+  }
+
+  /**
+   * 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(this.wsConnection && 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);
+        channels.forEach(channel => {
+          if (channel === 'allChannels') {
+            this.httpManagerService.sendBroadcast(messageInfo);
+          } else {
+            this.httpManagerService.sendChannelMessage(channel, messageInfo);
+          }
+        });
+      } 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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      this.httpManagerService.subscribeToChannel(channel);
+    } else {
+      console.warn('Cannot subscribe: WebSocket not connected.');
+    }
+  }
+
+  /**
+   * Subscribe to multiple channels at once
+   */
+  subscribeToChannels(channels: string[]) {
+    if (this.wsConnection) {
+      this.httpManagerService.subscribeToChannels(channels);
+    } else {
+      console.warn('Cannot subscribe: WebSocket not connected.');
+    }
+  }
+
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribeFromChannel(channel: string) {
+    if (this.wsConnection) {
+      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 (this.wsConnection) {
+      this.httpManagerService.createChannel(channel);
+    } else {
+      console.warn('Cannot create channel: WebSocket not connected.');
+    }
+  }
+
+  /**
+   * Delete a channel from the server
+   */
+  deleteChannel(channel: string) {
+    if (this.wsConnection) {
+      this.httpManagerService.deleteChannel(channel);
+    } else {
+      console.warn('Cannot delete channel: WebSocket not connected.');
+    }
+  }
+
+  /**
+   * Request list of all channels from server
+   */
+  getAllChannels() {
+    if (this.wsConnection) {
+      this.httpManagerService.getAllChannels();
+    } else {
+      console.warn('Cannot get channels: WebSocket not connected.');
+    }
+  }
+
+  /**
+   * Get users in a specific channel
+   */
+  getUsersInChannel(channel: string) {
+    if (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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 (this.wsConnection) {
+      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
+
+  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
+  }
+
+}