@futdevpro/fsm-dynamo 1.16.38 → 1.16.40

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

@@ -1,529 +1,529 @@
-import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult, second } from '../../../..';
-import { BehaviorSubject } from 'rxjs';
-
-import { DyFM_WritableSignalPlaceholder } from '../../_collections/angular-placeholders';
-import { DyFM_SignalDataHandler_Settings } from './data-handler-settings.control-model';
-
-/* export type DNM_DataHandler<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  Dependency_T extends DyFM_Metadata = any
-> = DyFM_SignalDataHandler<T, Dependency_T>; */
-
-/* export type DNM_DataHandler_Settings<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  Dependency_T extends DyFM_Metadata = any
-> = DyFM_SignalDataHandler_Settings<T, Dependency_T>; */
-
-/**
- * DyFM_SignalDataHandlerDataLoadInProgress
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export interface DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> {
-  loadBy: T_LoadBy;
-  progress: Promise<any>;
-}
-
-/**
- * DyFM_DataHandlerDataPostProcess
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export type DyFM_SignalDataHandlerDataLoadPostProcess<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',
- * });
- * @deprecated
- * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
- * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
- */
-export abstract class DyFM_SignalDataHandler<
-  T extends DyFM_Metadata | DyFM_Metadata[],
-  T_Dependency extends DyFM_Metadata = any,
-  T_LoadBy = string
-> {
-  name: string;
-
-  abstract readonly data_$: DyFM_WritableSignalPlaceholder<T>;
-  /**
-   * this is only declared if createObservable is set to true in settings
-   * (handled by DyNX_DataHandler)
-   */
-  protected abstract readonly data_BS: BehaviorSubject<T>;
-  get data(): T {
-    return this.data_$();
-  }
-
-  /**
-   * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
-   */
-  lastLoadedBy: 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_SignalDataHandlerDataLoadPostProcess<T_LoadBy>[] = [];
-
-  noId?: boolean;
-
-  abstract readonly loaded_$: DyFM_WritableSignalPlaceholder<boolean>;
-  abstract readonly loadInProgress_$: DyFM_WritableSignalPlaceholder<DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> | false>;
-  waitsOnLoad: {
-    promise: Promise<void>;
-    resolve: () => void;
-  }[] = [];
-
-  protected readonly dependentDataHandlers?: DyFM_SignalDataHandler<any>[] = [];
-
-  loopSafetyCollection: {
-    at: Date;
-    stack: string;
-  }[] = [];
-  loopSafetyTimeout: number = second;
-  /** if set to 0, loop safety will be disabled */
-  loopSafety: number = 10;
-  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_SignalDataHandler_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
-  ) {
-    try {
-      // 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;
-
-      if (set.loopSafety === undefined) {
-        set.loopSafety = 10;
-      } else {
-        this.loopSafety = set.loopSafety;
-      }
-
-      if (set.get) {
-        this.get = set.get;
-      }
-
-      if (set.set) {
-        this.set = set.set;
-      }
-
-      this.noId = !!set.noId;
-
-      if (!skipDependencyConnections) {
-        if (set.dependencyDataHandler) {
-          this.addDependencyDataHandler(set.dependencyDataHandler, true);
-        }
-    
-        if (set.dependentDataHandlers) {
-          this.addDependentDataHandlers(set.dependentDataHandlers, true);
-        }
-      }
-
-      if (set.getPostProcess) {
-        this.getPostProcesses.push(set.getPostProcess);
-      }
-    } catch (error) {
-      DyFM_Log.error(`Error creating DyFM_SignalDataHandler (${set.name}):`, error);
-    }
-  }
-
-  addDependencyDataHandler(dependencyDataHandler: DyFM_SignalDataHandler<any>, isInConstruct?: boolean): 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_SignalDataHandler)) {
-        throw new Error(
-          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
-          `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${this.name})`
-        );
-      }
-  
-      dependencyDataHandler.addDependentDataHandlers([ this ], isInConstruct);
-    } 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_SignalDataHandler<any, any, any>[],
-    isInConstruct?: boolean
-  ): void {
-    try {
-      dependentDataHandlers.forEach((dependent_DH: DyFM_SignalDataHandler<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_SignalDataHandler)) {
-          throw new Error(
-            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
-            `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${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_$) {
-          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['_id'] ? newData['_id'] : ''})`
-            );
-
-            return newData;
-          });
-        }
-
-        // Dependency _id változásának követése - csak akkor reload-oljuk a dependenseket, ha a dependency _id ténylegesen változott
-        // Inicializáljuk az aktuális dependency _id-vel, ha már van adat
-        /* let previousDependencyId: any = this.data && this.data['_id'] ? this.data['_id'] : undefined; */
-        
-        this.getPostProcesses.push(
-          async (newData: T): Promise<T> => {
-            if (newData && newData['_id'] && newData['_id'] !== dependent_DH.lastLoadedBy) {
-              dependent_DH.reloadData(newData['_id']);
-            } else if (!newData) {
-              dependent_DH.clear();
-            }
-            
-            /* const currentDependencyId = newData && newData['_id'] ? newData['_id'] : undefined;
-            
-            // Csak akkor reload-olunk, ha a dependency _id ténylegesen változott
-            if (currentDependencyId && currentDependencyId !== previousDependencyId) {
-              previousDependencyId = currentDependencyId;
-              if (currentDependencyId !== dependent_DH.lastLoadedBy) {
-                dependent_DH.reloadData(currentDependencyId);
-              }
-            } else if (!newData && previousDependencyId !== undefined) {
-              previousDependencyId = undefined;
-              dependent_DH.clear();
-            } */
-
-            return newData;
-          }
-        );
-
-        if (!isInConstruct && this.data) {
-          dependent_DH.reloadData(this.data['_id']);
-        }
-      });
-    } catch (error) {
-      DyFM_Log.error(`Error adding dependent data handlers in DyFM_SignalDataHandler (${this.name}):`, error);
-    }
-  }
-
-  /**
-   * 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 })
-   * @param opts BFR-MASTERPROMPTER-024: `silentMissingId` — a hiányzó-ID ág NE console.error-ozzon
-   *   (a throw MARAD). A `getData()` not-loaded-yet útja használja: friss boot-on a dependency-cascade
-   *   (header token-balance/user-data read) a session-restore ELŐTT ér ide → az ID-hiány ott
-   *   „még-nincs-betöltve", NEM caller-hiba — a korábbi feltétel-nélküli console.error minden
-   *   hard-nav-on 2 hamis error-t tett a konzolra (release-gate-zaj). Direct `reloadData()`-hívásnál
-   *   a hiba-log változatlan (valódi caller-hiba látható marad).
-   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
-   */
-  async reloadData(loadBy?: T_LoadBy, opts?: { silentMissingId?: boolean }): Promise<T> {
-    try {
-      const loadInProgress = this.loadInProgress_$();
-      const useLoadBy: T_LoadBy = loadBy ??
-        (this.data && this.data['_id'] ? this.data['_id'] : this.lastLoadedBy);
-
-      if (!useLoadBy && !this.noId) {
-        if (!opts?.silentMissingId) {
-          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_$.set({ 
-        loadBy: useLoadBy,
-        progress: loadProgress
-      });
-      loadProgress.finally(() => {
-        this.loadInProgress_$.set(false);
-      });
-
-      return await loadProgress;      
-    } catch (error) {
-      this.loadInProgress_$.set(false);
-      this.loaded_$.set(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_$();
-      if (loadProgress) {
-        return await loadProgress.progress;
-      } else {
-        // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján a hiányzó ID „még-nincs-betöltve"
-        // (boot-race a session-restore-ral), NEM caller-hiba → silent (a throw marad, a hívó catch-eli).
-        return await this.reloadData(undefined, { silentMissingId: true });
-      }
-    } 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;
-    }
-  }
-
-  /**
-   * Az adat közvetlen frissítése (round-trip nélkül; pl. SPA-login → user_DH.updateData). Alapból CSAK
-   * a saját `data_$`-t frissíti.
-   *
-   * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a dependent DataHandler-eket
-   *   (pl. token-balance) is újratölti az új adat `_id`-jével — a `reloadData` post-process
-   *   dependent-lánca az `updateData` (round-trip-mentes) úton eddig NEM futott → a friss SPA-login után
-   *   a dependent-DH-adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe: a vak
-   *   dependent-reload HTTP-flood-ot okozhatna, az updateData szándéka épp a szerver-hívás elkerülése).
-   */
-  async updateData(data: T, dontSendUpdate?: boolean, reloadDependents?: boolean): Promise<void> {
-    if (this.set && !dontSendUpdate) {
-      this.data_$.set(await this.set(data));
-    } else {
-      this.data_$.set(data);
-    }
-
-    if (reloadDependents) {
-      // ugyanaz a reload-vagy-clear logika, mint a reloadData dependent-lánc-postprocess-e
-      this.dependentDataHandlers?.forEach((dependent_DH: DyFM_SignalDataHandler<any>): void => {
-        if (data && data['_id'] && data['_id'] !== dependent_DH.lastLoadedBy) {
-          dependent_DH.reloadData(data['_id']);
-        } else if (!data) {
-          dependent_DH.clear();
-        }
-      });
-    }
-  }
-
-  clear(dontClearDependents?: boolean): void {
-    this.data_$.set(undefined);
-    this.lastLoadedBy = undefined;
-    if (!dontClearDependents) {
-      this.dependentDataHandlers.forEach((ddh: DyFM_SignalDataHandler<any>): void => {
-        ddh.clear();
-      });
-    }
-  }
-
-  protected async processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T> {
-    try {
-      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_$.set(result);
-      this.loaded_$.set(true);
-      this.resolveWaitsOnLoad();
-      return result;
-    } catch (error) {
-      DyFM_Log.error(`Error in DH.processLoadResult (${this.name}):`, error);
-      throw error;
-    }
-  }
-
-  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;
-  }
-
-  protected loopSafetyCheck(): void {
-    this.loopSafetyCollection = this.loopSafetyCollection.filter(
-      (item) => item.at.getTime() > new Date().getTime() - this.loopSafetyTimeout
-    );
-
-    this.loopSafetyCollection.push({
-      at: new Date(),
-      stack: new Error().stack,
-    });
-
-    if (this.loopSafetyCollection.length > this.loopSafety) {
-      throw new Error(
-        `DYNAMO DH.loopSafetyCheck (${this.name}) ERROR: ` +
-        `\n  Loop safety triggered! Count: ${this.loopSafetyCollection.length}` +
-        `\n  Timeout: ${this.loopSafetyTimeout} MaxCount: ${this.loopSafety} Stack: ${new Error().stack}`
-      );
-    }
-  }
-}
-
-
+import { DyFM_Log, DyFM_Metadata, DyFM_SearchQuery, DyFM_SearchResult, second } from '../../../..';
+import { BehaviorSubject } from 'rxjs';
+
+import { DyFM_WritableSignalPlaceholder } from '../../_collections/angular-placeholders';
+import { DyFM_SignalDataHandler_Settings } from './data-handler-settings.control-model';
+
+/* export type DNM_DataHandler<
+  T extends DyFM_Metadata | DyFM_Metadata[],
+  Dependency_T extends DyFM_Metadata = any
+> = DyFM_SignalDataHandler<T, Dependency_T>; */
+
+/* export type DNM_DataHandler_Settings<
+  T extends DyFM_Metadata | DyFM_Metadata[],
+  Dependency_T extends DyFM_Metadata = any
+> = DyFM_SignalDataHandler_Settings<T, Dependency_T>; */
+
+/**
+ * DyFM_SignalDataHandlerDataLoadInProgress
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export interface DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> {
+  loadBy: T_LoadBy;
+  progress: Promise<any>;
+}
+
+/**
+ * DyFM_DataHandlerDataPostProcess
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export type DyFM_SignalDataHandlerDataLoadPostProcess<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',
+ * });
+ * @deprecated
+ * meg kell nézni hogy mit kell az fsm-ből használni, és mit kell signal-osra alakítani
+ * ellenőrizni kell, hogy minden funkcionalitás átkerült az fsm-be mielőtt remove-oljuk ezeket
+ */
+export abstract class DyFM_SignalDataHandler<
+  T extends DyFM_Metadata | DyFM_Metadata[],
+  T_Dependency extends DyFM_Metadata = any,
+  T_LoadBy = string
+> {
+  name: string;
+
+  abstract readonly data_$: DyFM_WritableSignalPlaceholder<T>;
+  /**
+   * this is only declared if createObservable is set to true in settings
+   * (handled by DyNX_DataHandler)
+   */
+  protected abstract readonly data_BS: BehaviorSubject<T>;
+  get data(): T {
+    return this.data_$();
+  }
+
+  /**
+   * last loaded by will work properly only if you use the Dynamo form of "_id" for loading
+   */
+  lastLoadedBy: 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_SignalDataHandlerDataLoadPostProcess<T_LoadBy>[] = [];
+
+  noId?: boolean;
+
+  abstract readonly loaded_$: DyFM_WritableSignalPlaceholder<boolean>;
+  abstract readonly loadInProgress_$: DyFM_WritableSignalPlaceholder<DyFM_SignalDataHandlerDataLoadInProgress<T_LoadBy> | false>;
+  waitsOnLoad: {
+    promise: Promise<void>;
+    resolve: () => void;
+  }[] = [];
+
+  protected readonly dependentDataHandlers?: DyFM_SignalDataHandler<any>[] = [];
+
+  loopSafetyCollection: {
+    at: Date;
+    stack: string;
+  }[] = [];
+  loopSafetyTimeout: number = second;
+  /** if set to 0, loop safety will be disabled */
+  loopSafety: number = 10;
+  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_SignalDataHandler_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
+  ) {
+    try {
+      // 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;
+
+      if (set.loopSafety === undefined) {
+        set.loopSafety = 10;
+      } else {
+        this.loopSafety = set.loopSafety;
+      }
+
+      if (set.get) {
+        this.get = set.get;
+      }
+
+      if (set.set) {
+        this.set = set.set;
+      }
+
+      this.noId = !!set.noId;
+
+      if (!skipDependencyConnections) {
+        if (set.dependencyDataHandler) {
+          this.addDependencyDataHandler(set.dependencyDataHandler, true);
+        }
+    
+        if (set.dependentDataHandlers) {
+          this.addDependentDataHandlers(set.dependentDataHandlers, true);
+        }
+      }
+
+      if (set.getPostProcess) {
+        this.getPostProcesses.push(set.getPostProcess);
+      }
+    } catch (error) {
+      DyFM_Log.error(`Error creating DyFM_SignalDataHandler (${set.name}):`, error);
+    }
+  }
+
+  addDependencyDataHandler(dependencyDataHandler: DyFM_SignalDataHandler<any>, isInConstruct?: boolean): 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_SignalDataHandler)) {
+        throw new Error(
+          `DYNAMO DH.addDependencyDataHandler (${this.name}) ERROR: ` +
+          `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${this.name})`
+        );
+      }
+  
+      dependencyDataHandler.addDependentDataHandlers([ this ], isInConstruct);
+    } 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_SignalDataHandler<any, any, any>[],
+    isInConstruct?: boolean
+  ): void {
+    try {
+      dependentDataHandlers.forEach((dependent_DH: DyFM_SignalDataHandler<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_SignalDataHandler)) {
+          throw new Error(
+            `DYNAMO DH.addDependentDataHandlers (${this.name}) ERROR: ` +
+            `\n  Dependent DataHandler is not instance of DyFM_SignalDataHandler! (${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_$) {
+          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['_id'] ? newData['_id'] : ''})`
+            );
+
+            return newData;
+          });
+        }
+
+        // Dependency _id változásának követése - csak akkor reload-oljuk a dependenseket, ha a dependency _id ténylegesen változott
+        // Inicializáljuk az aktuális dependency _id-vel, ha már van adat
+        /* let previousDependencyId: any = this.data && this.data['_id'] ? this.data['_id'] : undefined; */
+        
+        this.getPostProcesses.push(
+          async (newData: T): Promise<T> => {
+            if (newData && newData['_id'] && newData['_id'] !== dependent_DH.lastLoadedBy) {
+              dependent_DH.reloadData(newData['_id']);
+            } else if (!newData) {
+              dependent_DH.clear();
+            }
+            
+            /* const currentDependencyId = newData && newData['_id'] ? newData['_id'] : undefined;
+            
+            // Csak akkor reload-olunk, ha a dependency _id ténylegesen változott
+            if (currentDependencyId && currentDependencyId !== previousDependencyId) {
+              previousDependencyId = currentDependencyId;
+              if (currentDependencyId !== dependent_DH.lastLoadedBy) {
+                dependent_DH.reloadData(currentDependencyId);
+              }
+            } else if (!newData && previousDependencyId !== undefined) {
+              previousDependencyId = undefined;
+              dependent_DH.clear();
+            } */
+
+            return newData;
+          }
+        );
+
+        if (!isInConstruct && this.data) {
+          dependent_DH.reloadData(this.data['_id']);
+        }
+      });
+    } catch (error) {
+      DyFM_Log.error(`Error adding dependent data handlers in DyFM_SignalDataHandler (${this.name}):`, error);
+    }
+  }
+
+  /**
+   * 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 })
+   * @param opts BFR-MASTERPROMPTER-024: `silentMissingId` — a hiányzó-ID ág NE console.error-ozzon
+   *   (a throw MARAD). A `getData()` not-loaded-yet útja használja: friss boot-on a dependency-cascade
+   *   (header token-balance/user-data read) a session-restore ELŐTT ér ide → az ID-hiány ott
+   *   „még-nincs-betöltve", NEM caller-hiba — a korábbi feltétel-nélküli console.error minden
+   *   hard-nav-on 2 hamis error-t tett a konzolra (release-gate-zaj). Direct `reloadData()`-hívásnál
+   *   a hiba-log változatlan (valódi caller-hiba látható marad).
+   * @returns the data as Promise<T>, finishes when the call ends (throws error on fail)
+   */
+  async reloadData(loadBy?: T_LoadBy, opts?: { silentMissingId?: boolean }): Promise<T> {
+    try {
+      const loadInProgress = this.loadInProgress_$();
+      const useLoadBy: T_LoadBy = loadBy ??
+        (this.data && this.data['_id'] ? this.data['_id'] : this.lastLoadedBy);
+
+      if (!useLoadBy && !this.noId) {
+        if (!opts?.silentMissingId) {
+          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_$.set({ 
+        loadBy: useLoadBy,
+        progress: loadProgress
+      });
+      loadProgress.finally(() => {
+        this.loadInProgress_$.set(false);
+      });
+
+      return await loadProgress;      
+    } catch (error) {
+      this.loadInProgress_$.set(false);
+      this.loaded_$.set(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_$();
+      if (loadProgress) {
+        return await loadProgress.progress;
+      } else {
+        // BFR-MASTERPROMPTER-024: a getData not-loaded-yet útján a hiányzó ID „még-nincs-betöltve"
+        // (boot-race a session-restore-ral), NEM caller-hiba → silent (a throw marad, a hívó catch-eli).
+        return await this.reloadData(undefined, { silentMissingId: true });
+      }
+    } 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;
+    }
+  }
+
+  /**
+   * Az adat közvetlen frissítése (round-trip nélkül; pl. SPA-login → user_DH.updateData). Alapból CSAK
+   * a saját `data_$`-t frissíti.
+   *
+   * @param reloadDependents opt-in (BFR-MASTERPROMPTER-013): ha true, a dependent DataHandler-eket
+   *   (pl. token-balance) is újratölti az új adat `_id`-jével — a `reloadData` post-process
+   *   dependent-lánca az `updateData` (round-trip-mentes) úton eddig NEM futott → a friss SPA-login után
+   *   a dependent-DH-adatok üresek maradtak hard-reload-ig. DEFAULT false (backward-safe: a vak
+   *   dependent-reload HTTP-flood-ot okozhatna, az updateData szándéka épp a szerver-hívás elkerülése).
+   */
+  async updateData(data: T, dontSendUpdate?: boolean, reloadDependents?: boolean): Promise<void> {
+    if (this.set && !dontSendUpdate) {
+      this.data_$.set(await this.set(data));
+    } else {
+      this.data_$.set(data);
+    }
+
+    if (reloadDependents) {
+      // ugyanaz a reload-vagy-clear logika, mint a reloadData dependent-lánc-postprocess-e
+      this.dependentDataHandlers?.forEach((dependent_DH: DyFM_SignalDataHandler<any>): void => {
+        if (data && data['_id'] && data['_id'] !== dependent_DH.lastLoadedBy) {
+          dependent_DH.reloadData(data['_id']);
+        } else if (!data) {
+          dependent_DH.clear();
+        }
+      });
+    }
+  }
+
+  clear(dontClearDependents?: boolean): void {
+    this.data_$.set(undefined);
+    this.lastLoadedBy = undefined;
+    if (!dontClearDependents) {
+      this.dependentDataHandlers.forEach((ddh: DyFM_SignalDataHandler<any>): void => {
+        ddh.clear();
+      });
+    }
+  }
+
+  protected async processLoadResult(result: any, loadedBy: T_LoadBy): Promise<T> {
+    try {
+      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_$.set(result);
+      this.loaded_$.set(true);
+      this.resolveWaitsOnLoad();
+      return result;
+    } catch (error) {
+      DyFM_Log.error(`Error in DH.processLoadResult (${this.name}):`, error);
+      throw error;
+    }
+  }
+
+  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;
+  }
+
+  protected loopSafetyCheck(): void {
+    this.loopSafetyCollection = this.loopSafetyCollection.filter(
+      (item) => item.at.getTime() > new Date().getTime() - this.loopSafetyTimeout
+    );
+
+    this.loopSafetyCollection.push({
+      at: new Date(),
+      stack: new Error().stack,
+    });
+
+    if (this.loopSafetyCollection.length > this.loopSafety) {
+      throw new Error(
+        `DYNAMO DH.loopSafetyCheck (${this.name}) ERROR: ` +
+        `\n  Loop safety triggered! Count: ${this.loopSafetyCollection.length}` +
+        `\n  Timeout: ${this.loopSafetyTimeout} MaxCount: ${this.loopSafety} Stack: ${new Error().stack}`
+      );
+    }
+  }
+}
+
+