@futdevpro/fsm-dynamo 1.15.21 → 1.15.22

package/src/_modules/data-handler/_models/data-list-handler.control-model.ts

@@ -1,252 +1,252 @@
-import { BehaviorSubject, Observable } from 'rxjs';
-
-import { DyFM_DataListHandler_Settings } from './data-handler-settings.control-model';
-
-import { DyFM_DataHandler } from './data-handler.control-model';
-import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
-import { DyFM_Log } from '../../../_collections/utils/log.util';
-
-/**
- * A specialized data handler for managing arrays of data items.
- * Extends DyFM_DataHandler to provide additional functionality for handling lists of data.
- * 
- * @template T_DataList - The type of the data list (must be an array of T_DataItem)
- * @template T_DependencyData - The type of dependency data (defaults to any)
- * @template T_DataLoadBy - The type used to identify how data should be loaded (defaults to string)
- * @template T_DataItem - The type of individual items in the list (must extend DyFM_Metadata)
- * 
- * @example
- * ```typescript
- * // Create a data list handler for user messages
- * const messagesHandler = new DyFM_DataListHandler<UserMessage[]>({
- *   get: async (userId: string): Promise<UserMessage[]> => {
- *     return await userApiService.getUserMessages(userId, 0, 100);
- *   }
- * });
- * 
- * // Access the data list
- * const messages = messagesHandler.dataList;
- * 
- * // Add a new message
- * messagesHandler.addItem(newMessage);
- * 
- * // Update an existing message
- * messagesHandler.updateItem(updatedMessage);
- * 
- * // Subscribe to changes
- * messagesHandler.dataList$.subscribe(messages => {
- *   console.log('Messages updated:', messages);
- * });
- * ```
- */
-export class DyFM_DataListHandler<
-  T_DataItem extends DyFM_Metadata,
-  T_DependencyData extends DyFM_Metadata = any,
-  T_DataLoadBy = string,
-  T_UpdateItemBy = string,
-> extends DyFM_DataHandler<T_DataItem[], T_DependencyData, T_DataLoadBy> {
-  
-  protected readonly setItem: (item: T_DataItem, updateBy?: T_UpdateItemBy) => Promise<T_DataItem>;
-  protected readonly deleteItem: (id: string, updateBy?: T_UpdateItemBy) => Promise<void>;
-
-  /**
-   * BehaviorSubject that holds the current data list.
-   * Computed from the base data_BS BehaviorSubject, ensuring it always returns an array.
-   */
-  protected readonly dataList_BS: BehaviorSubject<T_DataItem[]>;
-
-  /**
-   * Observable that holds the current data list.
-   * Computed from the base data$ Observable, ensuring it always returns an array.
-   */
-  readonly dataList$: Observable<T_DataItem[]>;
-
-  /**
-   * BehaviorSubject that holds the currently active item.
-   */
-  readonly activeItem_BS: BehaviorSubject<T_DataItem>;
-
-  /**
-   * Observable that holds the currently active item.
-   */
-  readonly activeItem$: Observable<T_DataItem>;
-
-  /**
-   * Gets the current data list.
-   * @returns The current array of data items
-   */
-  override get data(): T_DataItem[] {
-    return this.dataList_BS.value;
-  }
-
-  /**
-   * Gets the current data list.
-   * Alias for data getter.
-   * @returns The current array of data items
-   */
-  get dataList(): T_DataItem[] {
-    return this.dataList_BS.value;
-  }
-
-  /**
-   * Creates a new instance of DyFM_DataListHandler.
-   * 
-   * @param set - Configuration settings for the data handler
-   * @param skipDependencyConnections - Optional flag to skip dependency connections during construction
-   */
-  constructor(
-    set: DyFM_DataListHandler_Settings<T_DataItem, T_DependencyData, T_DataLoadBy, T_UpdateItemBy>,
-    /** is in construct? 
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections?: boolean,
-  ) {
-    super(set, skipDependencyConnections);
-    
-    // Initialize dataList BehaviorSubject and Observable
-    this.dataList_BS = new BehaviorSubject<T_DataItem[]>([]);
-    this.dataList$ = this.dataList_BS.asObservable();
-    
-    // Initialize activeItem BehaviorSubject and Observable
-    this.activeItem_BS = new BehaviorSubject<T_DataItem>(null);
-    this.activeItem$ = this.activeItem_BS.asObservable();
-
-    // Subscribe to data changes to update dataList
-    this.data$.subscribe(data => {
-      const dataList = Array.isArray(data) ? data : [];
-      this.dataList_BS.next(dataList);
-    });
-    
-    if (set.setItem) {
-      this.setItem = set.setItem;
-    }
-
-    if (set.deleteItem) {
-      this.deleteItem = set.deleteItem;
-    }
-
-    this.getPostProcesses.push((data: T_DataItem[]) => {
-      // check if data is an array
-      if (!Array.isArray(data) ) {
-        console.error(
-          `DYNAMO DataListHandler (${this.name}) ERROR: ` +
-          `\nData is not an array!:` +
-          '\n\n', data
-        );
-        throw new Error(`Data is not an array! (${this.name})`);
-      }
-
-      return data;
-    });
-
-    if (!skipDependencyConnections) {
-      if (set.dependencyDataHandler) {
-        this.addDependencyDataHandler(set.dependencyDataHandler);
-      }
-  
-      if (set.dependentDataHandlers) {
-        this.addDependentDataHandlers(set.dependentDataHandlers, true);
-      }
-    }
-  }
-
-  override async reloadData(loadBy?: T_DataLoadBy): Promise<T_DataItem[]> {
-    try {
-      const setActiveItem = !this.activeItem_BS.value || this.activeItem_BS.value?._id !== loadBy;
-      const dataList = await super.reloadData(loadBy);
-      if (setActiveItem && dataList.length > 0) {
-        this.setActiveItem(dataList[0]);
-      }
-      return dataList;
-    } catch (error) {
-      DyFM_Log.error(`Error reloading DyFM_DataListHandler (${this.name}):`, error);
-      
-      throw error;
-    }
-  }
-
-  override clear(dontClearDependents?: boolean): void {
-    super.clear(dontClearDependents);
-    this.activeItem_BS.next(null);
-  }
-
-  /**
-   * Adds a new item to the data list.
-   * 
-   * @param item - The item to add to the list
-   * @param updateBy - Optional parameter for update tracking
-   * @param dontSendUpdate - Optional flag to prevent sending update notification
-   */
-  async addItem(item: T_DataItem, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
-    const currentData = this.data;
-    currentData.push(item);
-    if (this.setItem && !dontSendUpdate) {
-      await this.setItem(item, updateBy);
-      // dont send update because we already sent it to the setItem function
-      await this.updateData(this.dataList_BS.value, true);
-    } else {
-      await this.updateData(this.dataList_BS.value, dontSendUpdate);
-    }
-    this.activeItem_BS.next(item);
-  }
-
-  /**
-   * Removes an item from the data list.
-   * The item is identified by its _id property.
-   * 
-   * @param id - The id of the item to remove from the list
-   * @param updateBy - Optional parameter for update tracking
-   * @param dontSendUpdate - Optional flag to prevent sending update notification
-   */
-  async removeItem(id: string, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
-    const currentData = this.data;
-    const index = currentData.findIndex(i => i._id === id);
-    if (index !== -1) {
-      currentData.splice(index, 1);
-      if (this.deleteItem) {
-        await this.deleteItem(id, updateBy);
-        await this.updateData(this.dataList_BS.value, true);
-      } else {
-        await this.updateData(this.dataList_BS.value, dontSendUpdate);
-      }
-    }
-    if (this.activeItem_BS.value?._id === id) {
-      this.activeItem_BS.next(null);
-    }
-  }
-
-  /**
-   * Updates an existing item in the data list.
-   * The item is identified by its _id property.
-   * 
-   * @param item - The updated item
-   * @param updateBy - Optional parameter for update tracking
-   * @param dontSendUpdate - Optional flag to prevent sending update notification
-   * @throws Error if the item is not found in the list
-   */
-  async updateItem(item: T_DataItem, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
-    const currentData = this.data;
-    const index = currentData.findIndex(i => i._id === item._id);
-    if (index !== -1) {
-      currentData[index] = item;
-      if (this.setItem) {
-        await this.setItem(item, updateBy);
-        await this.updateData(this.dataList_BS.value, true);
-      } else {
-        await this.updateData(this.dataList_BS.value, dontSendUpdate);
-      }
-    } else {
-      throw new DyFM_Error({
-        error: new Error(`Item not found! (${this.name})`),
-        errorCode: 'DyFM-DLH-UI1',
-        additionalContent: {
-          item: item,
-        },
-      });
-    }
-  }
-
-  setActiveItem(item: T_DataItem): void {
-    this.activeItem_BS.next(item);
-  }
-}
+import { BehaviorSubject, Observable } from 'rxjs';
+
+import { DyFM_DataListHandler_Settings } from './data-handler-settings.control-model';
+
+import { DyFM_DataHandler } from './data-handler.control-model';
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+
+/**
+ * A specialized data handler for managing arrays of data items.
+ * Extends DyFM_DataHandler to provide additional functionality for handling lists of data.
+ * 
+ * @template T_DataList - The type of the data list (must be an array of T_DataItem)
+ * @template T_DependencyData - The type of dependency data (defaults to any)
+ * @template T_DataLoadBy - The type used to identify how data should be loaded (defaults to string)
+ * @template T_DataItem - The type of individual items in the list (must extend DyFM_Metadata)
+ * 
+ * @example
+ * ```typescript
+ * // Create a data list handler for user messages
+ * const messagesHandler = new DyFM_DataListHandler<UserMessage[]>({
+ *   get: async (userId: string): Promise<UserMessage[]> => {
+ *     return await userApiService.getUserMessages(userId, 0, 100);
+ *   }
+ * });
+ * 
+ * // Access the data list
+ * const messages = messagesHandler.dataList;
+ * 
+ * // Add a new message
+ * messagesHandler.addItem(newMessage);
+ * 
+ * // Update an existing message
+ * messagesHandler.updateItem(updatedMessage);
+ * 
+ * // Subscribe to changes
+ * messagesHandler.dataList$.subscribe(messages => {
+ *   console.log('Messages updated:', messages);
+ * });
+ * ```
+ */
+export class DyFM_DataListHandler<
+  T_DataItem extends DyFM_Metadata,
+  T_DependencyData extends DyFM_Metadata = any,
+  T_DataLoadBy = string,
+  T_UpdateItemBy = string,
+> extends DyFM_DataHandler<T_DataItem[], T_DependencyData, T_DataLoadBy> {
+  
+  protected readonly setItem: (item: T_DataItem, updateBy?: T_UpdateItemBy) => Promise<T_DataItem>;
+  protected readonly deleteItem: (id: string, updateBy?: T_UpdateItemBy) => Promise<void>;
+
+  /**
+   * BehaviorSubject that holds the current data list.
+   * Computed from the base data_BS BehaviorSubject, ensuring it always returns an array.
+   */
+  protected readonly dataList_BS: BehaviorSubject<T_DataItem[]>;
+
+  /**
+   * Observable that holds the current data list.
+   * Computed from the base data$ Observable, ensuring it always returns an array.
+   */
+  readonly dataList$: Observable<T_DataItem[]>;
+
+  /**
+   * BehaviorSubject that holds the currently active item.
+   */
+  readonly activeItem_BS: BehaviorSubject<T_DataItem>;
+
+  /**
+   * Observable that holds the currently active item.
+   */
+  readonly activeItem$: Observable<T_DataItem>;
+
+  /**
+   * Gets the current data list.
+   * @returns The current array of data items
+   */
+  override get data(): T_DataItem[] {
+    return this.dataList_BS.value;
+  }
+
+  /**
+   * Gets the current data list.
+   * Alias for data getter.
+   * @returns The current array of data items
+   */
+  get dataList(): T_DataItem[] {
+    return this.dataList_BS.value;
+  }
+
+  /**
+   * Creates a new instance of DyFM_DataListHandler.
+   * 
+   * @param set - Configuration settings for the data handler
+   * @param skipDependencyConnections - Optional flag to skip dependency connections during construction
+   */
+  constructor(
+    set: DyFM_DataListHandler_Settings<T_DataItem, T_DependencyData, T_DataLoadBy, T_UpdateItemBy>,
+    /** is in construct? 
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections?: boolean,
+  ) {
+    super(set, skipDependencyConnections);
+    
+    // Initialize dataList BehaviorSubject and Observable
+    this.dataList_BS = new BehaviorSubject<T_DataItem[]>([]);
+    this.dataList$ = this.dataList_BS.asObservable();
+    
+    // Initialize activeItem BehaviorSubject and Observable
+    this.activeItem_BS = new BehaviorSubject<T_DataItem>(null);
+    this.activeItem$ = this.activeItem_BS.asObservable();
+
+    // Subscribe to data changes to update dataList
+    this.data$.subscribe(data => {
+      const dataList = Array.isArray(data) ? data : [];
+      this.dataList_BS.next(dataList);
+    });
+    
+    if (set.setItem) {
+      this.setItem = set.setItem;
+    }
+
+    if (set.deleteItem) {
+      this.deleteItem = set.deleteItem;
+    }
+
+    this.getPostProcesses.push((data: T_DataItem[]) => {
+      // check if data is an array
+      if (!Array.isArray(data) ) {
+        console.error(
+          `DYNAMO DataListHandler (${this.name}) ERROR: ` +
+          `\nData is not an array!:` +
+          '\n\n', data
+        );
+        throw new Error(`Data is not an array! (${this.name})`);
+      }
+
+      return data;
+    });
+
+    if (!skipDependencyConnections) {
+      if (set.dependencyDataHandler) {
+        this.addDependencyDataHandler(set.dependencyDataHandler);
+      }
+  
+      if (set.dependentDataHandlers) {
+        this.addDependentDataHandlers(set.dependentDataHandlers, true);
+      }
+    }
+  }
+
+  override async reloadData(loadBy?: T_DataLoadBy): Promise<T_DataItem[]> {
+    try {
+      const setActiveItem = !this.activeItem_BS.value || this.activeItem_BS.value?._id !== loadBy;
+      const dataList = await super.reloadData(loadBy);
+      if (setActiveItem && dataList.length > 0) {
+        this.setActiveItem(dataList[0]);
+      }
+      return dataList;
+    } catch (error) {
+      DyFM_Log.error(`Error reloading DyFM_DataListHandler (${this.name}):`, error);
+      
+      throw error;
+    }
+  }
+
+  override clear(dontClearDependents?: boolean): void {
+    super.clear(dontClearDependents);
+    this.activeItem_BS.next(null);
+  }
+
+  /**
+   * Adds a new item to the data list.
+   * 
+   * @param item - The item to add to the list
+   * @param updateBy - Optional parameter for update tracking
+   * @param dontSendUpdate - Optional flag to prevent sending update notification
+   */
+  async addItem(item: T_DataItem, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
+    const currentData = this.data;
+    currentData.push(item);
+    if (this.setItem && !dontSendUpdate) {
+      await this.setItem(item, updateBy);
+      // dont send update because we already sent it to the setItem function
+      await this.updateData(this.dataList_BS.value, true);
+    } else {
+      await this.updateData(this.dataList_BS.value, dontSendUpdate);
+    }
+    this.activeItem_BS.next(item);
+  }
+
+  /**
+   * Removes an item from the data list.
+   * The item is identified by its _id property.
+   * 
+   * @param id - The id of the item to remove from the list
+   * @param updateBy - Optional parameter for update tracking
+   * @param dontSendUpdate - Optional flag to prevent sending update notification
+   */
+  async removeItem(id: string, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
+    const currentData = this.data;
+    const index = currentData.findIndex(i => i._id === id);
+    if (index !== -1) {
+      currentData.splice(index, 1);
+      if (this.deleteItem) {
+        await this.deleteItem(id, updateBy);
+        await this.updateData(this.dataList_BS.value, true);
+      } else {
+        await this.updateData(this.dataList_BS.value, dontSendUpdate);
+      }
+    }
+    if (this.activeItem_BS.value?._id === id) {
+      this.activeItem_BS.next(null);
+    }
+  }
+
+  /**
+   * Updates an existing item in the data list.
+   * The item is identified by its _id property.
+   * 
+   * @param item - The updated item
+   * @param updateBy - Optional parameter for update tracking
+   * @param dontSendUpdate - Optional flag to prevent sending update notification
+   * @throws Error if the item is not found in the list
+   */
+  async updateItem(item: T_DataItem, updateBy?: T_UpdateItemBy, dontSendUpdate?: boolean): Promise<void> {
+    const currentData = this.data;
+    const index = currentData.findIndex(i => i._id === item._id);
+    if (index !== -1) {
+      currentData[index] = item;
+      if (this.setItem) {
+        await this.setItem(item, updateBy);
+        await this.updateData(this.dataList_BS.value, true);
+      } else {
+        await this.updateData(this.dataList_BS.value, dontSendUpdate);
+      }
+    } else {
+      throw new DyFM_Error({
+        error: new Error(`Item not found! (${this.name})`),
+        errorCode: 'DyFM-DLH-UI1',
+        additionalContent: {
+          item: item,
+        },
+      });
+    }
+  }
+
+  setActiveItem(item: T_DataItem): void {
+    this.activeItem_BS.next(item);
+  }
+}