@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

package/src/_collections/utils/async.util.spec.ts

@@ -1,398 +0,0 @@
-import { DyFM_Async } from './async.util';
-import { DyFM_Time } from './time.util';
-import { DyFM_Log } from './log.util';
-import { Observable } from 'rxjs';
-
-describe('| DyFM_Async', (): void => {
-
-  describe('| wait', (): void => {
-    it('| should delay execution for specified milliseconds', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.wait(100);
-      const endTime = Date.now();
-      const elapsed = endTime - startTime;
-
-      // Allow for some timing variance - wait should take at least some time
-      expect(elapsed).toBeGreaterThanOrEqual(0);
-      expect(elapsed).toBeLessThan(200);
-    });
-
-    it('| should handle zero delay', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.wait(0);
-      const endTime = Date.now();
-      const elapsed = endTime - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-
-    it('| should handle negative delay as zero', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.wait(-100);
-      const endTime = Date.now();
-      const elapsed = endTime - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-  });
-
-  describe('| sleep', (): void => {
-    it('| should be an alias for wait', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.sleep(100);
-      const endTime = Date.now();
-      const elapsed = endTime - startTime;
-
-      // Allow for some timing variance
-      expect(elapsed).toBeGreaterThanOrEqual(0);
-      expect(elapsed).toBeLessThan(200);
-    });
-  });
-
-  describe('| delay', (): void => {
-    it('| should be an alias for wait', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.delay(100);
-      const endTime = Date.now();
-      const elapsed = endTime - startTime;
-
-      // Allow for some timing variance
-      expect(elapsed).toBeGreaterThanOrEqual(0);
-      expect(elapsed).toBeLessThan(200);
-    });
-  });
-
-  describe('| waitUntil', (): void => {
-    it('| should resolve when check returns true', async (): Promise<void> => {
-      let checkCount = 0;
-      const check = (): boolean => {
-        checkCount++;
-        return checkCount >= 3;
-      };
-
-      // Use shorter timeout for faster test execution
-      // waitUntil(check, interval, timeout) - interval=100ms, timeout=500ms
-      await DyFM_Async.waitUntil(check, 100, 500);
-
-      expect(checkCount).toBeGreaterThanOrEqual(3);
-    });
-
-    it('| should use default interval and timeout when not provided', async (): Promise<void> => {
-      let checkCount = 0;
-      const check = (): boolean => {
-        checkCount++;
-        return checkCount >= 2;
-      };
-
-      // Use explicit shorter timeout to avoid default 10s timeout
-      // waitUntil(check, interval, timeout) - interval=100ms, timeout=500ms
-      await DyFM_Async.waitUntil(check, 100, 500);
-
-      expect(checkCount).toBeGreaterThanOrEqual(2);
-    });
-
-    it('| should handle check that returns true immediately', async (): Promise<void> => {
-      const check = (): boolean => true;
-      const startTime = Date.now();
-
-      // Use shorter timeout for faster test execution
-      await DyFM_Async.waitUntil(check, 10, 100);
-      const elapsed = Date.now() - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-  });
-
-  describe('| waitUntilAsync', (): void => {
-    it('| should resolve when async check returns true', async (): Promise<void> => {
-      let checkCount = 0;
-      const check = async (): Promise<boolean> => {
-        await DyFM_Async.wait(5);
-        checkCount++;
-        return checkCount >= 3;
-      };
-
-      // Use shorter timeout for faster test execution
-      await DyFM_Async.waitUntilAsync(check, 10, 100);
-
-      expect(checkCount).toBeGreaterThanOrEqual(3);
-    });
-
-    it('| should use default interval and timeout when not provided', async (): Promise<void> => {
-      let checkCount = 0;
-      const check = async (): Promise<boolean> => {
-        await DyFM_Async.wait(5);
-        checkCount++;
-        return checkCount >= 2;
-      };
-
-      // Use explicit shorter timeout to avoid default 10s timeout
-      await DyFM_Async.waitUntilAsync(check, 10, 100);
-
-      expect(checkCount).toBeGreaterThanOrEqual(2);
-    });
-
-    it('| should handle async check that returns true immediately', async (): Promise<void> => {
-      const check = async (): Promise<boolean> => {
-        return true;
-      };
-      const startTime = Date.now();
-
-      // Use shorter timeout for faster test execution
-      await DyFM_Async.waitUntilAsync(check, 10, 100);
-      const elapsed = Date.now() - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-  });
-
-  describe('| takeUntil', (): void => {
-    it('| should resolve when observable emits value that passes check', async (): Promise<void> => {
-      const observable = new Observable<number>((observer) => {
-        let count = 0;
-        const interval = setInterval(() => {
-          observer.next(count);
-          count++;
-          if (count > 10) {
-            clearInterval(interval);
-            observer.complete();
-          }
-        }, 10);
-      });
-
-      const result = await DyFM_Async.takeUntil(observable, (value?: number) => (value ?? 0) > 5);
-
-      expect(result).toBeGreaterThan(5);
-    });
-
-    it('| should handle check function that uses value parameter', async (): Promise<void> => {
-      const observable = new Observable<string>((observer) => {
-        setTimeout(() => observer.next('test'), 10);
-      });
-
-      const result = await DyFM_Async.takeUntil(observable, (value?: string) => value === 'test');
-
-      expect(result).toBe('test');
-    });
-
-    it('| should unsubscribe after resolving', async (): Promise<void> => {
-      let emitCount = 0;
-      const observable = new Observable<number>((observer) => {
-        const interval = setInterval(() => {
-          emitCount++;
-          observer.next(emitCount);
-        }, 10);
-      });
-
-      await DyFM_Async.takeUntil(observable, (value?: number) => (value ?? 0) >= 3);
-
-      // Use shorter wait time for faster test execution
-      await DyFM_Async.wait(30);
-      const finalEmitCount = emitCount;
-
-      expect(finalEmitCount).toBeLessThanOrEqual(6);
-    });
-  });
-
-  describe('| waitWithCountdownLogging', (): void => {
-    beforeEach(() => {
-      spyOn(DyFM_Log, 'info');
-      spyOn(DyFM_Log, 'success');
-    });
-
-    afterEach(async () => {
-      // Wait a bit to ensure all async operations complete
-      await DyFM_Async.wait(50);
-    });
-
-    it('| should handle zero duration', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.waitWithCountdownLogging(0, 'Zero Duration');
-      const elapsed = Date.now() - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-      expect(DyFM_Log.success).toHaveBeenCalledWith('✅ Zero Duration completed');
-    }, 10000);
-
-    it('| should handle negative duration as zero', async (): Promise<void> => {
-      const startTime = Date.now();
-      await DyFM_Async.waitWithCountdownLogging(-100, 'Negative Duration');
-      const elapsed = Date.now() - startTime;
-
-      expect(elapsed).toBeLessThan(50);
-    }, 10000);
-
-    describe('| getLogInterval branch coverage', (): void => {
-      // Test all branches of getLogInterval function (lines 155-168)
-      // This function is private, so we test it indirectly through waitWithCountdownLogging
-      // We use actual durations to trigger each branch condition
-      
-      it('| should use week interval for durations >= 4 weeks', async (): Promise<void> => {
-        // 4 weeks = 4 * 7 * 24 * 60 * 60 * 1000 = 2419200000 ms
-        // Use exactly 4 weeks to trigger the branch, but wait only a short time for test speed
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('1w');
-        const fourWeeks = 4 * 7 * 24 * 60 * 60 * 1000;
-        // Actually wait for the full duration to trigger the branch properly
-        const promise = DyFM_Async.waitWithCountdownLogging(fourWeeks, 'Week Test');
-        // Don't await - this would take 4 weeks! Instead, just verify the function is called
-        // The branch will be covered when the function calculates the interval
-        expect(promise).toBeDefined();
-        // Cancel the promise after a short time
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use day interval for durations >= 7 days but < 4 weeks', async (): Promise<void> => {
-        // 7 days = 7 * 24 * 60 * 60 * 1000 = 604800000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('1d');
-        const sevenDays = 7 * 24 * 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(sevenDays, 'Day Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 12 hour interval for durations >= 3 days but < 7 days', async (): Promise<void> => {
-        // 3 days = 3 * 24 * 60 * 60 * 1000 = 259200000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('12h');
-        const threeDays = 3 * 24 * 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(threeDays, '3 Days Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 3 hour interval for durations >= 12 hours but < 1 day', async (): Promise<void> => {
-        // 12 hours = 12 * 60 * 60 * 1000 = 43200000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('3h');
-        const twelveHours = 12 * 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(twelveHours, '12 Hours Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 1 hour interval for durations >= 6 hours but < 12 hours', async (): Promise<void> => {
-        // 6 hours = 6 * 60 * 60 * 1000 = 21600000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('1h');
-        const sixHours = 6 * 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(sixHours, '6 Hours Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 30 minute interval for durations >= 3 hours but < 6 hours', async (): Promise<void> => {
-        // 3 hours = 3 * 60 * 60 * 1000 = 10800000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('30m');
-        const threeHours = 3 * 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(threeHours, '3 Hours Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 10 minute interval for durations >= 1 hour but < 3 hours', async (): Promise<void> => {
-        // 1 hour = 60 * 60 * 1000 = 3600000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('10m');
-        const oneHour = 60 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(oneHour, '1 Hour Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 5 minute interval for durations >= 30 minutes but < 1 hour', async (): Promise<void> => {
-        // 30 minutes = 30 * 60 * 1000 = 1800000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('5m');
-        const thirtyMinutes = 30 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(thirtyMinutes, '30 Minutes Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 1 minute interval for durations >= 10 minutes but < 30 minutes', async (): Promise<void> => {
-        // 10 minutes = 10 * 60 * 1000 = 600000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('1m');
-        const tenMinutes = 10 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(tenMinutes, '10 Minutes Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 30 second interval for durations >= 5 minutes but < 10 minutes', async (): Promise<void> => {
-        // 5 minutes = 5 * 60 * 1000 = 300000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('30s');
-        const fiveMinutes = 5 * 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(fiveMinutes, '5 Minutes Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 10 second interval for durations >= 1 minute but < 5 minutes', async (): Promise<void> => {
-        // 1 minute = 60 * 1000 = 60000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('10s');
-        const oneMinute = 60 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(oneMinute, '1 Minute Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 5 second interval for durations >= 30 seconds but < 1 minute', async (): Promise<void> => {
-        // 30 seconds = 30 * 1000 = 30000 ms
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('5s');
-        const thirtySeconds = 30 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(thirtySeconds, '30 Seconds Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-
-      it('| should use 1 second interval for durations < 30 seconds', async (): Promise<void> => {
-        // 25 seconds = 25 * 1000 = 21000 ms (less than 30 seconds)
-        spyOn(DyFM_Time, 'getTimeInShortestString').and.returnValue('1s');
-        const twentyFiveSeconds = 25 * 1000;
-        const promise = DyFM_Async.waitWithCountdownLogging(twentyFiveSeconds, '25 Seconds Test');
-        expect(promise).toBeDefined();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }, 11000);
-    });
-  });
-
-  /**
-   * BFR-FDPTOKENSERVICE-024 — azonnal (szinkron) igaz predikátumnál a régi `const sub` TDZ-ben
-   * volt → ReferenceError, és a Promise SOHA nem oldott fel (a hívó örökké várt).
-   */
-  describe('| takeUntil (BFR-FDPTOKENSERVICE-024)', (): void => {
-    it('| AZONNAL igaz predikátum (BehaviorSubject-jellegű szinkron emisszió) → feloldás, nem ReferenceError', async (): Promise<void> => {
-      const syncObservable = new Observable<number>((observer): void => {
-        observer.next(42);
-      });
-
-      const result = await DyFM_Async.takeUntil(syncObservable, (value?: number): boolean => value === 42);
-
-      expect(result).toBe(42);
-    });
-
-    it('| aszinkron emissziónál változatlanul az első check-igaz értékkel old fel', async (): Promise<void> => {
-      const asyncObservable = new Observable<number>((observer): void => {
-        setTimeout((): void => observer.next(1), 5);
-        setTimeout((): void => observer.next(7), 15);
-      });
-
-      const result = await DyFM_Async.takeUntil(asyncObservable, (value?: number): boolean => !!value && value > 5);
-
-      expect(result).toBe(7);
-    });
-
-    it('| szinkron eset: a feloldás után nem dolgoz fel további emissziót (resolved-őr)', async (): Promise<void> => {
-      const seen: (number | undefined)[] = [];
-      const multiSync = new Observable<number>((observer): void => {
-        observer.next(1);
-        observer.next(2);
-        observer.next(3);
-      });
-
-      const result = await DyFM_Async.takeUntil(multiSync, (value?: number): boolean => {
-        seen.push(value);
-        return true;
-      });
-
-      expect(result).toBe(1);
-      expect(seen).toEqual([ 1 ]);
-    });
-  });
-});
-

package/src/_collections/utils/async.util.ts

@@ -1,209 +0,0 @@
-import { Observable, Subscription } from 'rxjs';
-import { second, hour, minute, week, day } from '../constants/times.const';
-import { DyFM_Time } from './time.util';
-import { DyFM_Log } from './log.util';
-
-
-export class DyFM_Async {
-    
-  /**
-   * delays the execution of a function
-   * @param ms 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * await DyFM_Async.wait(1000);
-   * ```
-   */
-  static wait(ms: number): Promise<void> {
-    return new Promise((resolve): any => setTimeout(resolve, ms));
-  }
-  static readonly sleep: typeof this.wait = this.wait;
-  static readonly delay: typeof this.wait = this.wait;
-
-  /** 
-   * WARNING: This function is recommended to use ONLY for limited instances,
-   * because it can cause performance issues.
-   * 
-   * @example
-   * ```ts
-   * await DyFM_Async.waitUntil(() => check(), 100, 10000);
-   * ```
-   */
-  static waitUntil(
-    check: () => boolean, 
-    interval: number = 100,
-    timeout: number = 10_000
-  ): Promise<void> {
-    const timeoutError = new Error('waitUntil timeout');
-
-    return new Promise((resolve, reject): void => {
-      const startTime = Date.now();
-
-      const intervalId = setInterval((): void => {
-        if (check()) {
-          clearInterval(intervalId);
-          resolve();
-        } else if (Date.now() - startTime > timeout) {
-          clearInterval(intervalId);
-
-          reject(timeoutError);
-        }
-      }, interval);
-    });
-  }
-
-  /** 
-   * WARNING: This function is recommended to use ONLY for limited instances,
-   * because it can cause performance issues.
-   * 
-   * @example
-   * const result = await DyFM_Async.waitUntilAsync(
-   *   () => check(),
-   *   30 * second,
-   *   5 * minute,
-   * );
-   */
-  static waitUntilAsync(
-    check: () => Promise<boolean>, 
-    interval: number = 100,
-    timeout: number = 10000
-  ): Promise<void> {
-    const timeoutError = new Error('waitUntilAsync timeout');
-
-    return new Promise((resolve, reject): void => {
-      const startTime = Date.now();
-
-      const intervalId = setInterval(async (): Promise<void> => {
-        if (await check()) {
-          clearInterval(intervalId);
-          resolve();
-        } else if (Date.now() - startTime > timeout) {
-          clearInterval(intervalId);
-          
-          reject(timeoutError);
-        }
-      }, interval);
-    });
-  }
-
-  /**
-   * Creates a promise that resolves when the observable emits a value that passes the check function
-   * 
-   * @example
-   * ```ts
-   * const observable = new Observable<number>(observer => {
-   *   setInterval(() => observer.next(Math.random()), 100);
-   * });
-   * const result = await DyFM_Async.takeUntil(observable, (value?: number) => value && value > 0.5);
-   * ```
-   */
-  static takeUntil<T>(
-    observable: Observable<T>,
-    check: (value?: T) => boolean
-  ): Promise<T> {
-    return new Promise((resolve): void => {
-      // BFR-FDPTOKENSERVICE-024: szinkron emissziónál (BehaviorSubject / of) a callback még a
-      // subscribe visszatérte ELŐTT fut — `const sub` ekkor TDZ-ben lenne (ReferenceError, és a
-      // Promise sosem oldana fel). `let` + resolved-jelző; a leiratkozás ilyenkor utólag történik.
-      let resolved: boolean = false;
-      let sub: Subscription | undefined;
-
-      sub = observable.subscribe(
-        (value?: T): void => {
-          if (!resolved && check(value)) {
-            resolved = true;
-            sub?.unsubscribe();
-            resolve(value as T);
-          }
-        }
-      );
-
-      if (resolved) {
-        sub.unsubscribe();
-      }
-    });
-  }
-
-  /**
-   * Waits for a given amount of time and logs the remaining time.
-   * @param totalWaitTimeMs - The total amount of time to wait.
-   * @param context - The context of the countdown.
-   * @returns A promise that resolves when the countdown is complete.
-   * 
-   * @example
-   * ```ts
-   * await DyFM_Async.waitWithCountdownLogging(1000, 'Countdown');
-   * ```
-   */
-  static async waitWithCountdownLogging(
-    totalWaitTimeMs: number,
-    context: string = 'Countdown'
-  ): Promise<void> {
-    const startTime = Date.now();
-    const endTime = startTime + totalWaitTimeMs;
-    
-    // Define logging intervals based on total duration
-    /**
-     * Gets the logging interval based on the total duration.
-     * @param totalMs - The total duration in milliseconds.
-     * @returns The logging interval in milliseconds.
-     * 
-     * @example
-     * ```ts
-     * const logInterval = getLogInterval(1000);
-     * console.log(logInterval); // 1000
-     * ```
-     */
-    const getLogInterval = (totalMs: number): number => {
-      const totalSeconds = totalMs / second;
-      const totalMinutes = totalSeconds / 60;
-      const totalHours = totalMinutes / 60;
-      const totalDays = totalHours / 24;
-      const totalWeeks = totalDays / 7;
-      
-      if (totalWeeks >= 4) return week; // Every week
-      if (totalDays >= 7) return day; // Every day
-      if (totalDays >= 3) return 12 * hour; // Every 12 hours
-      if (totalDays >= 1) return 6 * hour; // Every 6 hours
-      if (totalHours >= 12) return 3 * hour; // Every 3 hours
-      if (totalHours >= 6) return hour; // Every hour
-      if (totalHours >= 3) return 30 * minute; // Every 30 minutes
-      if (totalHours >= 1) return 10 * minute; // Every 10 minutes
-      if (totalMinutes >= 30) return 5 * minute; // Every 5 minutes
-      if (totalMinutes >= 10) return minute; // Every minute
-      if (totalMinutes >= 5) return 30 * second; // Every 30 seconds
-      if (totalMinutes >= 1) return 10 * second; // Every 10 seconds
-      if (totalSeconds >= 30) return 5 * second; // Every 5 seconds
-      return second; // Every second
-    };
-    
-    const logInterval = getLogInterval(totalWaitTimeMs);
-    let lastLogTime = startTime;
-    
-    // Format remaining time for display using DyFM_Time utility
-    const formatRemainingTime = (remainingMs: number): string => DyFM_Time.getTimeInShortestString(remainingMs) as string;
-    
-    // Log initial countdown start
-    DyFM_Log.info(`⏳ ${context} started - Total duration: ${formatRemainingTime(totalWaitTimeMs)}`);
-    
-    while (Date.now() < endTime) {
-      const now = Date.now();
-      const remainingMs = endTime - now;
-      
-      // Check if it's time to log
-      if (now - lastLogTime >= logInterval) {
-        const remainingTime = formatRemainingTime(remainingMs);
-        DyFM_Log.info(`⏳ ${context} - ${remainingTime} remaining`);
-        lastLogTime = now;
-      }
-      
-      // Wait for a short interval before checking again
-      await DyFM_Async.wait(Math.min(DyFM_Time.second, remainingMs));
-    }
-    
-    // Log completion
-    DyFM_Log.success(`✅ ${context} completed`);
-  }
-}