@futdevpro/fsm-dynamo 1.15.18 → 1.15.20

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

@@ -1,459 +1,459 @@
-import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult } from '../../..';
-import { BehaviorSubject, Observable } from 'rxjs';
-
-import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
-
-/**
- * DyFM_DataHandlerDataLoadInProgress
- */
-export interface DyFM_DataHandlerDataLoadInProgress<T_LoadBy> {
-  loadBy: T_LoadBy;
-  progress: Promise<any>;
-}
-
-/**
- * DyFM_DataHandlerDataPostProcess
- */
-export type DyFM_DataHandlerDataLoadPostProcess<T_LoadBy> = (data: any, loadedBy: T_LoadBy) => Promise<any> | any;
-
-/**
- * DynamoDataHandler is used to create application wide data handling
- * used to create subscribeAble data handler
- *
- * this implements data reload function that uses predefined apiService,
- * using previous or given id,
- * prevents multiple load calls and triggers data change subscriptions when done
- *
- * load post processes can be implemented to ensure special conditions
- *
- * @example
- * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
- *   apiService: this.accountApiService,
- *   getDataFunctionName: 'getPersonalInformation',
- * });
- */
-export abstract class DyFM_DataHandler<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  T_Dependency extends DyFM_Metadata = any,
-  T_LoadBy = string
-> {
-  name: string;
-
-  /**
-   * BehaviorSubject that holds the current data value.
-   * This is the source of truth for data in DyFM.
-   */
-  protected readonly data_BS: BehaviorSubject<T>;
-
-  /**
-   * Observable that emits the current data value.
-   * Derived from the BehaviorSubject.
-   */
-  readonly data$: Observable<T>;
-
-  /**
-   * BehaviorSubject that indicates whether the data has been loaded.
-   * True when data is loaded, false otherwise.
-   */
-  protected readonly loaded_BS: BehaviorSubject<boolean>;
-
-  /**
-   * Observable that indicates whether the data has been loaded.
-   */
-  readonly loaded$: Observable<boolean>;
-
-  /**
-   * BehaviorSubject that tracks the current loading operation.
-   * Contains information about the ongoing data load operation or false if no load is in progress.
-   */
-  protected readonly loadInProgress_BS: BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
-
-  /**
-   * Observable that tracks the current loading operation.
-   */
-  readonly loadInProgress$: Observable<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
-
-  /**
-   * Gets the current data value.
-   * @returns The current data value
-   */
-  abstract get data(): T;
-
-  /**
-   * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
-   */
-  lastLoadedBy: T_LoadBy; // for lists
-  defaultLoadBy: T_LoadBy; // for lists
-
-  /** this will handle the data loading from the api */
-  protected readonly get: (loadBy?: T_LoadBy) => Promise<any>;
-  /** this will handle the data setting to the data handler */
-  protected readonly set: (data: T) => Promise<T>;
-  /** this will handle the data patching to the data handler */
-  /* patch: (data: T) => Promise<T>; */
-
-  // TODO
-  /* directApiSetup: any; */
-
-  /**
-   * post processes will be called as pipes after data is loaded by get function,
-   * but before data is set to data handler by data_$.set (after get, before Signal triggers)
-   */
-  protected readonly getPostProcesses: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>[] = [];
-
-  noId?: boolean;
-
-  waitsOnLoad: {
-    promise: Promise<void>;
-    resolve: () => void;
-  }[] = [];
-
-  protected readonly dependentDataHandlers?: DyFM_DataHandler<any>[] = [];
-
-  debugLog?: boolean;
-
-  /**
-   * DynamoDataHandler
-   * @param apiService any service can be used as apiService
-   * as long as the function, you pass in getDataFunctionName exists,
-   * uses (or not uses an ID as input) and returns the data as Promise<Type>
-   * @param getDataFunctionName the function name on the apiService,
-   * that will be used as get api call
-   *
-   * @param successfulReloadCallBack you can create direct callback for successful reloads
-   * by passing it here
-   *
-   * @param getPostPreprocessLoad post processes can be implemented to ensure special conditions on data
-   *
-   * @param defaultValue you can set default value that will be used before any load
-   * @param noId this flag needs to be true, when using api function without id
-   *
-   * @example
-   * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
-   *   apiService: this.accountApiService,
-   *   getDataFunctionName: 'getPersonalInformation',
-   * });
-   */
-  constructor(
-    set: DyFM_DataHandler_Settings<T, T_Dependency, T_LoadBy>,
-    /** is in construct? 
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections?: boolean
-  ) {
-    // TODO: + TRYTOGETTYPE(this.data);
-    if (!set.name) {
-      set.name = 'Unnamed DataHandler ' + (+new Date());
-
-      DyFM_Log.warn(
-        `DYNAMO DH.constructor (${this.name}) WARN: ` +
-        `\n  Name is not set!`,
-        '\n\n', new Error()
-      );
-    }
-
-    this.name = set.name; 
-    this.debugLog = set?.debugLog;
-
-    // Initialize BehaviorSubjects
-    this.data_BS = new BehaviorSubject<T>(set.defaultValue);
-    this.data$ = this.data_BS.asObservable();
-    
-    this.loaded_BS = new BehaviorSubject<boolean>(false);
-    this.loaded$ = this.loaded_BS.asObservable();
-    
-    this.loadInProgress_BS = new BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>(false);
-    this.loadInProgress$ = this.loadInProgress_BS.asObservable();
-
-    if (set.get) {
-      this.get = set.get;
-    }
-
-    if (set.set) {
-      this.set = set.set;
-    }
-
-    this.noId = !!set.noId;
-
-    if (set.defaultLoadBy) {
-      this.defaultLoadBy = set.defaultLoadBy;
-    }
-
-    if (!skipDependencyConnections) {
-      if (set.dependencyDataHandler) {
-        this.addDependencyDataHandler(set.dependencyDataHandler);
-      }
-  
-      if (set.dependentDataHandlers) {
-        this.addDependentDataHandlers(set.dependentDataHandlers, true);
-      }
-    }
-
-    if (set.getPostProcess) {
-      this.getPostProcesses.push(set.getPostProcess);
-    }
-  }
-
-  addDependencyDataHandler(dependencyDataHandler: DyFM_DataHandler<any>): void {
-    try {
-      if (!dependencyDataHandler) {
-        throw new Error(
-          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is null or undefined! (${this.name})`
-        );
-      }
-  
-      if (!(dependencyDataHandler instanceof DyFM_DataHandler)) {
-        throw new Error(
-          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`
-        );
-      }
-  
-      dependencyDataHandler.addDependentDataHandlers([ this ]);
-    } catch (error) {
-      console.error(
-        `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-        `\n  Failed to add dependency data handler! ("${this.name}": "${this.constructor.name}")`,
-        '\n\n', error,
-        '\n\n', new Error()
-      );
-    }
-  }
-
-  addDependentDataHandlers(
-    dependentDataHandlers: DyFM_DataHandler<any, any, any>[],
-    isInConstruct?: boolean
-  ): void {
-    dependentDataHandlers.forEach((dependent_DH: DyFM_DataHandler<any>): void => {
-      if (!dependent_DH) {
-        throw new Error(
-          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is null or undefined! (${this.name})`
-        );
-      }
-
-      if (!(dependent_DH instanceof DyFM_DataHandler)) {
-        throw new Error(
-          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`
-        );
-      }
-
-      if (dependent_DH.name === this.name) {
-        throw new Error(
-          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler has the same name as the current DataHandler! (${this.name})`
-        );
-      }
-
-      if (!dependent_DH.data_BS) {
-        throw new Error(
-          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler has not been set up yet! ` +
-          `(this: "${this.name}", dependent: "${dependent_DH.name}")` +
-          `\n    Try the opposite direction of dependency!\n\n`
-        );
-      }
-
-      if (!dependentDataHandlers.includes(dependent_DH)) {
-        dependentDataHandlers.push(dependent_DH);
-      }
-
-      if (this.debugLog) {
-        this.getPostProcesses.push(async (newData: T): Promise<T> => {
-          console.log(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) DEBUG:` +
-            `\nDataHandler triggering dependent dataHandler (${dependent_DH.name}) to reload... ` +
-            `\n(using id: ${newData && (newData as DyFM_Metadata)._id ? (newData as DyFM_Metadata)._id : ''})`
-          );
-
-          return newData;
-        });
-      }
-
-      this.getPostProcesses.push(
-        async (newData: T): Promise<T> => {
-          if (newData && (newData as DyFM_Metadata)._id && (newData as DyFM_Metadata)._id !== dependent_DH.lastLoadedBy) {
-            dependent_DH.reloadData((newData as DyFM_Metadata)._id);
-          } else if (!newData) {
-            dependent_DH.clear();
-          }
-
-          return newData;
-        }
-      );
-
-      if (!isInConstruct && this.data) {
-        dependent_DH.reloadData((this.data as DyFM_Metadata)._id);
-      }
-    });
-  }
-
-  /**
-   * reloads data on DynamoDataHandler using predefined apiservice,
-   * using previous or given id,
-   * prevents multiple load calls and triggers data change subscriptions when done
-   * @param loadBy previous or given id (or can be disabled trough setup by: { noId: true })
-   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
-   */
-  async reloadData(loadBy?: T_LoadBy): Promise<T> {
-    try {
-      const loadInProgress = this.loadInProgress_BS.value;
-      const useLoadBy: T_LoadBy = loadBy ??
-        ((this.data as DyFM_Metadata)?._id as T_LoadBy) ?? 
-        this.lastLoadedBy ??
-        this.defaultLoadBy;
-
-      if (!useLoadBy && !this.noId) {
-        console.error(
-          `DynamoERROR (DH.reloadData): Missing ID! (${this.name})`,
-          this.data,
-          '\n\n', new Error()
-        );
-
-        throw new Error(`DynamoERROR (DH.reloadData): Missing ID! (${this.name})`);
-      }
-
-      if (loadInProgress && loadInProgress.loadBy === useLoadBy) {
-        if (this.debugLog) {
-          console.log(
-            `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
-            `\n  DataHandler reloadData... (using id: ${useLoadBy})` +
-            `\n  DataHandler is already loading data...`
-          );
-        }
-
-        return this.data;
-      }
-
-      if (this.debugLog) {
-        console.log(
-          `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
-          `\n  DataHandler reloadData... (using id: ${useLoadBy})`
-        );
-      }
-
-      const loadProgress = this.doReloadDataBy(useLoadBy);
-      this.loadInProgress_BS.next({ 
-        loadBy: useLoadBy,
-        progress: loadProgress
-      });
-      loadProgress.finally(() => {
-        this.loadInProgress_BS.next(false);
-      });
-
-      return await loadProgress;      
-    } catch (error) {
-      this.loadInProgress_BS.next(false);
-      this.loaded_BS.next(false);
-
-      if (!error?.error?.handled) {
-        console.error(
-          `DYNAMO DH.reloadData (${this.name}) ERROR: ` +
-          `\n  reloadData was UNSUCCESSFUL`,
-          '\n\n', error,
-          '\n\n', new Error()
-        );
-
-        if (error?.error?.flag?.includes('DYNAMO')) {
-          error.error.handled = true;
-        }
-      }
-
-      throw error;
-    }
-  }
-
-  async getData(): Promise<T> {
-    if (!this.data) {
-      const loadProgress = this.loadInProgress_BS.value;
-      if (loadProgress) {
-        return await loadProgress.progress;
-      } else {
-        return await this.reloadData();
-      }
-    } else {
-      return this.data;
-    }
-  }
-
-  protected async doReloadDataBy(loadedBy: T_LoadBy): Promise<T> {
-    try {
-      this.lastLoadedBy = loadedBy;
-
-      return await this.processLoadResult(await this.get(loadedBy), loadedBy);
-    } catch (error) {
-      this.resolveWaitsOnLoad();
-      throw error;
-    }
-  }
-
-  async updateData(data: T, dontSendUpdate?: boolean): Promise<void> {
-    if (this.set && !dontSendUpdate) {
-      this.data_BS.next(await this.set(data));
-    } else {
-      this.data_BS.next(data);
-    }
-  }
-
-  clear(dontClearDependents?: boolean): void {
-    this.data_BS.next(undefined);
-    this.lastLoadedBy = undefined;
-    if (!dontClearDependents) {
-      this.dependentDataHandlers.forEach((ddh: DyFM_DataHandler<any>): void => {
-        ddh.clear();
-      });
-    }
-  }
-
-  protected async processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T> {
-    if (this.debugLog) {
-      console.log(
-        `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
-        `\n  DataHandler processLoadResult... (using id: ${loadedBy})` +
-        `\n  Result:`, result
-      );
-    }
-
-    for (const postProcess of this.getPostProcesses) {
-      if (this.debugLog) {
-        console.log(
-          `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
-          `\n  Post process:`, postProcess
-        );
-      }
-      
-      result = await postProcess(result, loadedBy);
-
-      if (!result) {
-        DyFM_Log.warn(
-          `DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
-          `\nPost process returned null or undefined!`,
-          '\n\n', new Error()
-        );
-      }
-    }
-    this.data_BS.next(result);
-    this.loaded_BS.next(true);
-    this.resolveWaitsOnLoad();
-    return result;
-  }
-
-  private resolveWaitsOnLoad(): void {
-    this.waitsOnLoad.forEach(({ promise, resolve }) => {
-      resolve();
-    });
-    this.waitsOnLoad = [];
-  }
-
-  /**
-   * waits for the first load to finish
-   * @returns a promise that resolves when the first load finishes after this "subscription"
-   */
-  waitForLoad(): Promise<void> {
-    let resolve: (value: void) => void;
-    const promise = new Promise<void>((r) => { resolve = r; });
-    this.waitsOnLoad.push({ promise, resolve });
-    return promise;
-  }
-}
+import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult } from '../../..';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
+
+/**
+ * DyFM_DataHandlerDataLoadInProgress
+ */
+export interface DyFM_DataHandlerDataLoadInProgress<T_LoadBy> {
+  loadBy: T_LoadBy;
+  progress: Promise<any>;
+}
+
+/**
+ * DyFM_DataHandlerDataPostProcess
+ */
+export type DyFM_DataHandlerDataLoadPostProcess<T_LoadBy> = (data: any, loadedBy: T_LoadBy) => Promise<any> | any;
+
+/**
+ * DynamoDataHandler is used to create application wide data handling
+ * used to create subscribeAble data handler
+ *
+ * this implements data reload function that uses predefined apiService,
+ * using previous or given id,
+ * prevents multiple load calls and triggers data change subscriptions when done
+ *
+ * load post processes can be implemented to ensure special conditions
+ *
+ * @example
+ * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
+ *   apiService: this.accountApiService,
+ *   getDataFunctionName: 'getPersonalInformation',
+ * });
+ */
+export abstract class DyFM_DataHandler<
+  T extends DyFM_Metadata | DyFM_Metadata[],
+  T_Dependency extends DyFM_Metadata = any,
+  T_LoadBy = string
+> {
+  name: string;
+
+  /**
+   * BehaviorSubject that holds the current data value.
+   * This is the source of truth for data in DyFM.
+   */
+  protected readonly data_BS: BehaviorSubject<T>;
+
+  /**
+   * Observable that emits the current data value.
+   * Derived from the BehaviorSubject.
+   */
+  readonly data$: Observable<T>;
+
+  /**
+   * BehaviorSubject that indicates whether the data has been loaded.
+   * True when data is loaded, false otherwise.
+   */
+  protected readonly loaded_BS: BehaviorSubject<boolean>;
+
+  /**
+   * Observable that indicates whether the data has been loaded.
+   */
+  readonly loaded$: Observable<boolean>;
+
+  /**
+   * BehaviorSubject that tracks the current loading operation.
+   * Contains information about the ongoing data load operation or false if no load is in progress.
+   */
+  protected readonly loadInProgress_BS: BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
+
+  /**
+   * Observable that tracks the current loading operation.
+   */
+  readonly loadInProgress$: Observable<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>;
+
+  /**
+   * Gets the current data value.
+   * @returns The current data value
+   */
+  abstract get data(): T;
+
+  /**
+   * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
+   */
+  lastLoadedBy: T_LoadBy; // for lists
+  defaultLoadBy: T_LoadBy; // for lists
+
+  /** this will handle the data loading from the api */
+  protected readonly get: (loadBy?: T_LoadBy) => Promise<any>;
+  /** this will handle the data setting to the data handler */
+  protected readonly set: (data: T) => Promise<T>;
+  /** this will handle the data patching to the data handler */
+  /* patch: (data: T) => Promise<T>; */
+
+  // TODO
+  /* directApiSetup: any; */
+
+  /**
+   * post processes will be called as pipes after data is loaded by get function,
+   * but before data is set to data handler by data_$.set (after get, before Signal triggers)
+   */
+  protected readonly getPostProcesses: DyFM_DataHandlerDataLoadPostProcess<T_LoadBy>[] = [];
+
+  noId?: boolean;
+
+  waitsOnLoad: {
+    promise: Promise<void>;
+    resolve: () => void;
+  }[] = [];
+
+  protected readonly dependentDataHandlers?: DyFM_DataHandler<any>[] = [];
+
+  debugLog?: boolean;
+
+  /**
+   * DynamoDataHandler
+   * @param apiService any service can be used as apiService
+   * as long as the function, you pass in getDataFunctionName exists,
+   * uses (or not uses an ID as input) and returns the data as Promise<Type>
+   * @param getDataFunctionName the function name on the apiService,
+   * that will be used as get api call
+   *
+   * @param successfulReloadCallBack you can create direct callback for successful reloads
+   * by passing it here
+   *
+   * @param getPostPreprocessLoad post processes can be implemented to ensure special conditions on data
+   *
+   * @param defaultValue you can set default value that will be used before any load
+   * @param noId this flag needs to be true, when using api function without id
+   *
+   * @example
+   * personalInformationDH = new DynamoDataHandler<PersonalInformation>({
+   *   apiService: this.accountApiService,
+   *   getDataFunctionName: 'getPersonalInformation',
+   * });
+   */
+  constructor(
+    set: DyFM_DataHandler_Settings<T, T_Dependency, T_LoadBy>,
+    /** is in construct? 
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections?: boolean
+  ) {
+    // TODO: + TRYTOGETTYPE(this.data);
+    if (!set.name) {
+      set.name = 'Unnamed DataHandler ' + (+new Date());
+
+      DyFM_Log.warn(
+        `DYNAMO DH.constructor (${this.name}) WARN: ` +
+        `\n  Name is not set!`,
+        '\n\n', new Error()
+      );
+    }
+
+    this.name = set.name; 
+    this.debugLog = set?.debugLog;
+
+    // Initialize BehaviorSubjects
+    this.data_BS = new BehaviorSubject<T>(set.defaultValue);
+    this.data$ = this.data_BS.asObservable();
+    
+    this.loaded_BS = new BehaviorSubject<boolean>(false);
+    this.loaded$ = this.loaded_BS.asObservable();
+    
+    this.loadInProgress_BS = new BehaviorSubject<DyFM_DataHandlerDataLoadInProgress<T_LoadBy> | false>(false);
+    this.loadInProgress$ = this.loadInProgress_BS.asObservable();
+
+    if (set.get) {
+      this.get = set.get;
+    }
+
+    if (set.set) {
+      this.set = set.set;
+    }
+
+    this.noId = !!set.noId;
+
+    if (set.defaultLoadBy) {
+      this.defaultLoadBy = set.defaultLoadBy;
+    }
+
+    if (!skipDependencyConnections) {
+      if (set.dependencyDataHandler) {
+        this.addDependencyDataHandler(set.dependencyDataHandler);
+      }
+  
+      if (set.dependentDataHandlers) {
+        this.addDependentDataHandlers(set.dependentDataHandlers, true);
+      }
+    }
+
+    if (set.getPostProcess) {
+      this.getPostProcesses.push(set.getPostProcess);
+    }
+  }
+
+  addDependencyDataHandler(dependencyDataHandler: DyFM_DataHandler<any>): void {
+    try {
+      if (!dependencyDataHandler) {
+        throw new Error(
+          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler is null or undefined! (${this.name})`
+        );
+      }
+  
+      if (!(dependencyDataHandler instanceof DyFM_DataHandler)) {
+        throw new Error(
+          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`
+        );
+      }
+  
+      dependencyDataHandler.addDependentDataHandlers([ this ]);
+    } catch (error) {
+      console.error(
+        `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+        `\n  Failed to add dependency data handler! ("${this.name}": "${this.constructor.name}")`,
+        '\n\n', error,
+        '\n\n', new Error()
+      );
+    }
+  }
+
+  addDependentDataHandlers(
+    dependentDataHandlers: DyFM_DataHandler<any, any, any>[],
+    isInConstruct?: boolean
+  ): void {
+    dependentDataHandlers.forEach((dependent_DH: DyFM_DataHandler<any>): void => {
+      if (!dependent_DH) {
+        throw new Error(
+          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler is null or undefined! (${this.name})`
+        );
+      }
+
+      if (!(dependent_DH instanceof DyFM_DataHandler)) {
+        throw new Error(
+          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler is not instance of DyFM_DataHandler! (${this.name})`
+        );
+      }
+
+      if (dependent_DH.name === this.name) {
+        throw new Error(
+          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler has the same name as the current DataHandler! (${this.name})`
+        );
+      }
+
+      if (!dependent_DH.data_BS) {
+        throw new Error(
+          `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler has not been set up yet! ` +
+          `(this: "${this.name}", dependent: "${dependent_DH.name}")` +
+          `\n    Try the opposite direction of dependency!\n\n`
+        );
+      }
+
+      if (!dependentDataHandlers.includes(dependent_DH)) {
+        dependentDataHandlers.push(dependent_DH);
+      }
+
+      if (this.debugLog) {
+        this.getPostProcesses.push(async (newData: T): Promise<T> => {
+          console.log(
+            `DYNAMO DH.addDependentDataHandlers (${this.name}) DEBUG:` +
+            `\nDataHandler triggering dependent dataHandler (${dependent_DH.name}) to reload... ` +
+            `\n(using id: ${newData && (newData as DyFM_Metadata)._id ? (newData as DyFM_Metadata)._id : ''})`
+          );
+
+          return newData;
+        });
+      }
+
+      this.getPostProcesses.push(
+        async (newData: T): Promise<T> => {
+          if (newData && (newData as DyFM_Metadata)._id && (newData as DyFM_Metadata)._id !== dependent_DH.lastLoadedBy) {
+            dependent_DH.reloadData((newData as DyFM_Metadata)._id);
+          } else if (!newData) {
+            dependent_DH.clear();
+          }
+
+          return newData;
+        }
+      );
+
+      if (!isInConstruct && this.data) {
+        dependent_DH.reloadData((this.data as DyFM_Metadata)._id);
+      }
+    });
+  }
+
+  /**
+   * reloads data on DynamoDataHandler using predefined apiservice,
+   * using previous or given id,
+   * prevents multiple load calls and triggers data change subscriptions when done
+   * @param loadBy previous or given id (or can be disabled trough setup by: { noId: true })
+   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
+   */
+  async reloadData(loadBy?: T_LoadBy): Promise<T> {
+    try {
+      const loadInProgress = this.loadInProgress_BS.value;
+      const useLoadBy: T_LoadBy = loadBy ??
+        ((this.data as DyFM_Metadata)?._id as T_LoadBy) ?? 
+        this.lastLoadedBy ??
+        this.defaultLoadBy;
+
+      if (!useLoadBy && !this.noId) {
+        console.error(
+          `DynamoERROR (DH.reloadData): Missing ID! (${this.name})`,
+          this.data,
+          '\n\n', new Error()
+        );
+
+        throw new Error(`DynamoERROR (DH.reloadData): Missing ID! (${this.name})`);
+      }
+
+      if (loadInProgress && loadInProgress.loadBy === useLoadBy) {
+        if (this.debugLog) {
+          console.log(
+            `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
+            `\n  DataHandler reloadData... (using id: ${useLoadBy})` +
+            `\n  DataHandler is already loading data...`
+          );
+        }
+
+        return this.data;
+      }
+
+      if (this.debugLog) {
+        console.log(
+          `DYNAMO DH.reloadData (${this.name}) DEBUG:` +
+          `\n  DataHandler reloadData... (using id: ${useLoadBy})`
+        );
+      }
+
+      const loadProgress = this.doReloadDataBy(useLoadBy);
+      this.loadInProgress_BS.next({ 
+        loadBy: useLoadBy,
+        progress: loadProgress
+      });
+      loadProgress.finally(() => {
+        this.loadInProgress_BS.next(false);
+      });
+
+      return await loadProgress;      
+    } catch (error) {
+      this.loadInProgress_BS.next(false);
+      this.loaded_BS.next(false);
+
+      if (!error?.error?.handled) {
+        console.error(
+          `DYNAMO DH.reloadData (${this.name}) ERROR: ` +
+          `\n  reloadData was UNSUCCESSFUL`,
+          '\n\n', error,
+          '\n\n', new Error()
+        );
+
+        if (error?.error?.flag?.includes('DYNAMO')) {
+          error.error.handled = true;
+        }
+      }
+
+      throw error;
+    }
+  }
+
+  async getData(): Promise<T> {
+    if (!this.data) {
+      const loadProgress = this.loadInProgress_BS.value;
+      if (loadProgress) {
+        return await loadProgress.progress;
+      } else {
+        return await this.reloadData();
+      }
+    } else {
+      return this.data;
+    }
+  }
+
+  protected async doReloadDataBy(loadedBy: T_LoadBy): Promise<T> {
+    try {
+      this.lastLoadedBy = loadedBy;
+
+      return await this.processLoadResult(await this.get(loadedBy), loadedBy);
+    } catch (error) {
+      this.resolveWaitsOnLoad();
+      throw error;
+    }
+  }
+
+  async updateData(data: T, dontSendUpdate?: boolean): Promise<void> {
+    if (this.set && !dontSendUpdate) {
+      this.data_BS.next(await this.set(data));
+    } else {
+      this.data_BS.next(data);
+    }
+  }
+
+  clear(dontClearDependents?: boolean): void {
+    this.data_BS.next(undefined);
+    this.lastLoadedBy = undefined;
+    if (!dontClearDependents) {
+      this.dependentDataHandlers.forEach((ddh: DyFM_DataHandler<any>): void => {
+        ddh.clear();
+      });
+    }
+  }
+
+  protected async processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T> {
+    if (this.debugLog) {
+      console.log(
+        `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
+        `\n  DataHandler processLoadResult... (using id: ${loadedBy})` +
+        `\n  Result:`, result
+      );
+    }
+
+    for (const postProcess of this.getPostProcesses) {
+      if (this.debugLog) {
+        console.log(
+          `DYNAMO DH.processLoadResult (${this.name}) DEBUG:` +
+          `\n  Post process:`, postProcess
+        );
+      }
+      
+      result = await postProcess(result, loadedBy);
+
+      if (!result) {
+        DyFM_Log.warn(
+          `DYNAMO DH.processLoadResult (${this.name}) WARN: ` +
+          `\nPost process returned null or undefined!`,
+          '\n\n', new Error()
+        );
+      }
+    }
+    this.data_BS.next(result);
+    this.loaded_BS.next(true);
+    this.resolveWaitsOnLoad();
+    return result;
+  }
+
+  private resolveWaitsOnLoad(): void {
+    this.waitsOnLoad.forEach(({ promise, resolve }) => {
+      resolve();
+    });
+    this.waitsOnLoad = [];
+  }
+
+  /**
+   * waits for the first load to finish
+   * @returns a promise that resolves when the first load finishes after this "subscription"
+   */
+  waitForLoad(): Promise<void> {
+    let resolve: (value: void) => void;
+    const promise = new Promise<void>((r) => { resolve = r; });
+    this.waitsOnLoad.push({ promise, resolve });
+    return promise;
+  }
+}