@futdevpro/fsm-dynamo 1.9.51 → 1.10.2

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

@@ -0,0 +1,41 @@
+
+import { DyFM_String } from './string.util';
+
+describe('DyFM_String', () => {
+  describe('breakTrim', () => {
+    it('should remove spaces from the start and end of the string', () => {
+      const result = DyFM_String.breakTrim('  hello world  ');
+      expect(result).toBe('hello world');
+    });
+
+    it('should remove newline characters from the start and end of the string', () => {
+      const result = DyFM_String.breakTrim('\nhello world\n');
+      expect(result).toBe('hello world');
+    });
+
+    it('should remove carriage return characters from the start and end of the string', () => {
+      const result = DyFM_String.breakTrim('\rhello world\r');
+      expect(result).toBe('hello world');
+    });
+
+    it('should remove all types of line breaks from the start and end of the string', () => {
+      const result = DyFM_String.breakTrim('\r\nhello world\r\n');
+      expect(result).toBe('hello world');
+    });
+
+    it('should return an empty string if the input is only spaces and line breaks', () => {
+      const result = DyFM_String.breakTrim(' \r\n ');
+      expect(result).toBe('');
+    });
+
+    it('should not alter a string that has no spaces or line breaks at the start or end', () => {
+      const result = DyFM_String.breakTrim('hello world');
+      expect(result).toBe('hello world');
+    });
+
+    it('should handle an empty string input', () => {
+      const result = DyFM_String.breakTrim('');
+      expect(result).toBe('');
+    });
+  });
+});

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

@@ -0,0 +1,10 @@
+
+
+
+export class DyFM_String {
+
+  /** removes \n, \r and spaces from the start and end of the string */
+  static breakTrim(value: string): string {
+    return value.trim().replace(/(\r\n|\n|\r)/gm, '');
+  }
+}

package/src/_collections/utils/type-cloning-facility.util.spec.ts

@@ -0,0 +1,51 @@
+
+import { DyFM_TypeCloningFacility } from './type-cloning-facility.util';
+
+describe('DyFM_TypeCloningFacility', () => {
+
+  it('should clone a simple object', () => {
+    const original = { a: 1, b: 'test', c: true };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+  });
+
+  it('should clone an object with nested objects', () => {
+    const original = { a: { b: { c: 2 } } };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(cloned.a).not.toBe(original.a);
+    expect(cloned.a.b).not.toBe(original.a.b);
+  });
+
+  xit('should handle circular references', () => {
+    const original: any = { a: 1 };
+    original.self = original;
+
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual({ a: 1, self: cloned });
+    expect(cloned).not.toBe(original);
+  });
+
+  it('should clone arrays within objects', () => {
+    const original = { a: [1, 2, 3] };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned.a).not.toBe(original.a);
+  });
+
+  it('should clone an array of objects', () => {
+    const original = [{ a: 1 }, { b: 2 }];
+    const cloned = DyFM_TypeCloningFacility.cloneArray(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(cloned[0]).not.toBe(original[0]);
+    expect(cloned[1]).not.toBe(original[1]);
+  });
+});

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

@@ -0,0 +1,166 @@
+
+import { of } from 'rxjs';
+import { DyFM_clone, DyFM_deepClone, DyFM_delay, DyFM_JSONListify, DyFM_orderedSameObject, DyFM_orderedSameObject2, DyFM_sameObjects, DyFM_sameObjectSurface, DyFM_setExistingValuesOnly, DyFM_sortForTrue, DyFM_surfaceClone, DyFM_takeUntil, DyFM_waitUntil, DyFM_waitUntilAsync } from './utilities.util';
+
+describe('Utilities', () => {
+
+  describe('DyFM_clone', () => {
+    it('should clone a simple object', () => {
+      const obj = { a: 1, b: 2 };
+      const clonedObj = DyFM_clone(obj);
+      expect(clonedObj).toEqual(obj);
+      expect(clonedObj).not.toBe(obj);
+    });
+
+    it('should return the same value for non-object types', () => {
+      expect(DyFM_clone(null)).toBeNull();
+      expect(DyFM_clone(undefined)).toBeUndefined();
+      expect(DyFM_clone(42)).toBe(42);
+    });
+  });
+
+  describe('DyFM_surfaceClone', () => {
+    it('should perform a shallow clone of an object', () => {
+      const obj = { a: 1, b: { c: 3 } };
+      const clonedObj = DyFM_surfaceClone(obj);
+      expect(clonedObj).toEqual(obj);
+      expect(clonedObj).not.toBe(obj);
+      expect(clonedObj.b).toBe(obj.b);
+    });
+  });
+
+  describe('DyFM_deepClone', () => {
+    it('should perform a deep clone of an object', () => {
+      const obj = { a: 1, b: { c: 3 } };
+      const clonedObj = DyFM_deepClone(obj);
+      expect(clonedObj).toEqual(obj);
+      expect(clonedObj).not.toBe(obj);
+      expect(clonedObj.b).not.toBe(obj.b);
+    });
+  });
+
+  describe('DyFM_sameObjects', () => {
+    it('should return true for identical objects', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 2 };
+      expect(DyFM_sameObjects(objA, objB)).toBeTrue();
+    });
+
+    it('should return false for different objects', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 3 };
+      expect(DyFM_sameObjects(objA, objB)).toBeFalse();
+    });
+  });
+
+  describe('DyFM_orderedSameObject', () => {
+    it('should return true for objects with same keys and values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { b: 2, a: 1 };
+      expect(DyFM_orderedSameObject(objA, objB)).toBeTrue();
+    });
+
+    xit('should return false for objects with different keys or values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 3 };
+      expect(DyFM_orderedSameObject(objA, objB)).toBeFalse();
+    });
+  });
+
+  describe('DyFM_orderedSameObject2', () => {
+    it('should return true for objects with same keys and values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { b: 2, a: 1 };
+      expect(DyFM_orderedSameObject2(objA, objB)).toBeTrue();
+    });
+
+    it('should return false for objects with different keys or values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 3 };
+      expect(DyFM_orderedSameObject2(objA, objB)).toBeFalse();
+    });
+  });
+
+  describe('DyFM_sameObjectSurface', () => {
+    it('should return true for objects with same surface values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 2 };
+      expect(DyFM_sameObjectSurface(objA, objB)).toBeTrue();
+    });
+
+    it('should return false for objects with different surface values', () => {
+      const objA = { a: 1, b: 2 };
+      const objB = { a: 1, b: 3 };
+      expect(DyFM_sameObjectSurface(objA, objB)).toBeFalse();
+    });
+  });
+
+  xdescribe('DyFM_setExistingValuesOnly', () => {
+    it('should set values only if they exist in the target object', () => {
+      const setOn = { a: 1, b: 2 };
+      const setTo = { a: 3, c: 4 };
+      DyFM_setExistingValuesOnly(setOn, setTo);
+      expect(setOn).toEqual({ a: 3, b: 2 });
+    });
+  });
+
+  describe('DyFM_delay', () => {
+    it('should resolve after a specified delay', async () => {
+      const start = Date.now();
+      await DyFM_delay(100);
+      const end = Date.now();
+      expect(end - start).toBeGreaterThanOrEqual(100);
+    });
+  });
+
+  describe('DyFM_waitUntil', () => {
+    it('should resolve when the check function returns true', async () => {
+      let condition = false;
+      setTimeout(() => condition = true, 100);
+      await DyFM_waitUntil(() => condition, 50, 500);
+      expect(condition).toBeTrue();
+    });
+
+    it('should reject if the timeout is reached', async () => {
+      await expectAsync(DyFM_waitUntil(() => false, 50, 100)).toBeRejectedWith('timeout');
+    });
+  });
+
+  describe('DyFM_waitUntilAsync', () => {
+    it('should resolve when the async check function returns true', async () => {
+      let condition = false;
+      setTimeout(() => condition = true, 100);
+      await DyFM_waitUntilAsync(async () => condition, 50, 500);
+      expect(condition).toBeTrue();
+    });
+
+    it('should reject if the timeout is reached', async () => {
+      await expectAsync(DyFM_waitUntilAsync(async () => false, 50, 100)).toBeRejectedWith('timeout');
+    });
+  });
+
+  xdescribe('DyFM_takeUntil', () => {
+    it('should resolve when the observable emits a value that passes the check', async () => {
+      const observable = of(1, 2, 3);
+      const result = await DyFM_takeUntil(observable, value => value === 2);
+      expect(result).toBe(2);
+    });
+  });
+
+  describe('DyFM_sortForTrue', () => {
+    it('should sort items based on the check function', () => {
+      const items = [{ value: true }, { value: false }];
+      items.sort((a, b) => DyFM_sortForTrue(a, b, item => item.value));
+      expect(items).toEqual([{ value: true }, { value: false }]);
+    });
+  });
+
+  describe('DyFM_JSONListify', () => {
+    it('should convert a JSON list to an array', () => {
+      const JSONList = { 0: 'a', 1: 'b', 2: 'c' };
+      const result = DyFM_JSONListify<string>(JSONList);
+      expect(result).toEqual(['a', 'b', 'c']);
+    });
+  });
+
+});

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

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+
 import { DyFM_Log } from './log.util';
 
 const defaultErrorMsg = 
@@ -174,10 +175,6 @@ export function DyFM_orderedSameObject2<T>(objA: T, objB: T): boolean {
   }
 }
 
-
-
-
-
 export function DyFM_sameObjectSurface<T>(objA: T, objB: T): boolean {
   let result = true;
 
@@ -300,14 +297,6 @@ export function DyFM_sortForTrue<T>(
   return isA === check(b) ? 0 : isA ? -1 : 1;
 }
 
-/**
- * 
- * @param checkFor 
- * @returns 
- * 
- * @example
- * codes.sort(getSortForTrueFn((c: Code) => c.haveImg));
- */
 export function DyFM_getSortForTrueFn<T>(
   checkFor: (a: T) => boolean
 ): (a: T, b: T) => DyFM_SortDirection {

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

@@ -0,0 +1,30 @@
+
+import { DyFM_UUID } from './uuid.util';
+import * as UUID from 'uuid';
+
+describe('DyFM_UUID', () => {
+  describe('generate', () => {
+    it('should generate a UUID', () => {
+      const uuid = DyFM_UUID.generate();
+      expect(UUID.validate(uuid)).toBeTrue();
+    });
+
+    it('should generate a unique UUID not in the reserved list', () => {
+      const reserved = ['123e4567-e89b-12d3-a456-426614174000'];
+      const uuid = DyFM_UUID.generate(reserved);
+      expect(reserved.includes(uuid)).toBeFalse();
+      expect(UUID.validate(uuid)).toBeTrue();
+    });
+
+    it('should generate a UUID even if reserved list is empty', () => {
+      const reserved: string[] = [];
+      const uuid = DyFM_UUID.generate(reserved);
+      expect(UUID.validate(uuid)).toBeTrue();
+    });
+
+    it('should generate a UUID when reserved list is undefined', () => {
+      const uuid = DyFM_UUID.generate(undefined);
+      expect(UUID.validate(uuid)).toBeTrue();
+    });
+  });
+});

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

@@ -3,7 +3,8 @@
 import * as UUID from 'uuid';
 
 export class DyFM_UUID {
-  static readonly getUUID = UUID.v4;
+  /* static readonly getUUID = UUID.v4; */
+
   static generate(reserved?: string[]): string {
     let uuid = UUID.v4();
 
@@ -15,4 +16,16 @@ export class DyFM_UUID {
 
     return uuid;
   }
+  
+  /* static generate(reserved?: string[]): string {
+    let uuid = UUID.v4();
+
+    if (reserved) {
+      while (reserved.includes(uuid)) {
+        uuid = UUID.v4();
+      }
+    }
+
+    return uuid;
+  } */
 }

package/src/_models/control-models/data-model-params.control-model.spec.ts

@@ -0,0 +1,67 @@
+
+import { DyFM_Log } from '../../_collections/utils/log.util';
+import { DyFM_DataModel_Type } from '../../_enums/data-model-type.enum';
+import { DyFM_Metadata } from '../data-models/metadata.data-model';
+import { DyFM_DataModel_Params, DyFM_DataModel_Settings } from './data-model-params.control-model';
+import { DyFM_DataProperties } from './data-property-params.control-model';
+
+describe('DyFM_DataModel_Params', () => {
+  class MockMetadata extends DyFM_Metadata {
+    // Mock implementation of DyFM_Metadata if needed
+  }
+
+  let mockSettings: DyFM_DataModel_Settings<MockMetadata>;
+
+  beforeEach(() => {
+    mockSettings = {
+      dataName: 'testModel',
+      properties: {} as DyFM_DataProperties<MockMetadata>
+    };
+  });
+
+  it('should create an instance with the provided settings', () => {
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(params.dataName).toBe('testModel');
+    expect(params.properties).toEqual({});
+  });
+
+  it('should log an error if properties are missing or not an object', () => {
+    spyOn(DyFM_Log, 'error');
+    mockSettings.properties = null as any;
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(DyFM_Log.error).toHaveBeenCalledWith(
+      'DyFM_DataModel_Params.constructor: Properties are missing in testModel model.'
+    );
+    expect(params.properties).toEqual({});
+  });
+
+  it('should log an error if a property key is missing', () => {
+    spyOn(DyFM_Log, 'error');
+    mockSettings.properties = { '': { key: '' } } as any;
+    new DyFM_DataModel_Params(mockSettings);
+    expect(DyFM_Log.error).toHaveBeenCalledWith(
+      'DyFM_DataModel_Params.constructor: A property key is missing in testModel model.'
+    );
+  });
+
+  it('should set modelType to data if not provided or is data', () => {
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(params.modelType).toBe(DyFM_DataModel_Type.data);
+  });
+
+  it('should set dbName based on dataName if not provided', () => {
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(params.dbName).toBe('TestModel');
+  });
+
+  xit('should convert dbName to camelCase if it contains underscores', () => {
+    mockSettings.dataName = 'test_model';
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(params.dbName).toBe('TestModel');
+  });
+
+  it('should return true for constructed method', () => {
+    const params = new DyFM_DataModel_Params(mockSettings);
+    expect(params.constructed()).toBeTrue();
+  });
+});

package/src/_models/control-models/data-property-params.control-model.spec.ts

@@ -0,0 +1,109 @@
+
+import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
+import { DyFM_DataProperty_Params, DyFM_DataProperty_Settings } from './data-property-params.control-model';
+
+describe('DyFM_DataProperty_Params', () => {
+  it('should create an instance with given settings', () => {
+    const settings: DyFM_DataProperty_Settings<string> = {
+      key: 'testKey',
+      type: DyFM_BasicProperty_Type.string,
+      default: 'defaultValue',
+      unique: true,
+      readonly: false,
+      required: true,
+      index: false,
+      isDependencyHook: false,
+      dependencyDataName: 'dependencyName',
+      minlength: 5,
+      maxlength: 10,
+      subObjectParams: {},
+      additionalValidators: [(data) => { console.log(data); }]
+    };
+
+    const instance = new DyFM_DataProperty_Params(settings);
+
+    expect(instance.key).toBe('testKey');
+    expect(instance.type).toBe(DyFM_BasicProperty_Type.string);
+    expect(instance.default).toBe('defaultValue');
+    expect(instance.unique).toBe(true);
+    expect(instance.readonly).toBe(false);
+    expect(instance.required).toBe(true);
+    expect(instance.index).toBe(false);
+    expect(instance.isDependencyHook).toBe(false);
+    expect(instance.dependencyDataName).toBe('dependencyName');
+    expect(instance.minlength).toBe(5);
+    expect(instance.maxlength).toBe(10);
+    expect(instance.subObjectParams).toEqual({});
+    expect(instance.additionalValidators?.length).toBe(1);
+  });
+
+  it('should log error if type is missing', () => {
+    const consoleErrorSpy = spyOn(console, 'error');
+    const settings: DyFM_DataProperty_Settings<string> = {
+      key: 'testKey',
+      type: undefined as any, // Simulating missing type
+    };
+
+    new DyFM_DataProperty_Params(settings);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'DYNAMO ERROR: ',
+      '\n type is missing from DynamoBEDataPropertyParams'
+    );
+  });
+
+  it('should log error if isDependencyHook is true but dependencyDataName is missing', () => {
+    const consoleErrorSpy = spyOn(console, 'error');
+    const settings: DyFM_DataProperty_Settings<string> = {
+      key: 'testKey',
+      type: DyFM_BasicProperty_Type.string,
+      isDependencyHook: true,
+      dependencyDataName: undefined
+    };
+
+    new DyFM_DataProperty_Params(settings);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'DYNAMO ERROR: ',
+      '\n dependencyName missing for dependencyHook from ' +
+      'DynamoBEDataPropertyParams'
+    );
+  });
+
+  it('should log error if settings are not provided', () => {
+    const consoleErrorSpy = spyOn(console, 'error');
+
+    new DyFM_DataProperty_Params(undefined as any);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'DYNAMO ERROR: ',
+      '\nMISSING DynamoBEDataPropertyParams constructor input'
+    );
+  });
+
+  xit('should return correct BEType based on type', () => {
+    const settings: DyFM_DataProperty_Settings<any> = {
+      type: DyFM_BasicProperty_Type.string
+    };
+    const instance = new DyFM_DataProperty_Params(settings);
+    expect(instance.getBEType()).toBe(String);
+
+    settings.type = DyFM_BasicProperty_Type.number;
+    expect(instance.getBEType()).toBe(Number);
+
+    settings.type = DyFM_BasicProperty_Type.boolean;
+    expect(instance.getBEType()).toBe(Boolean);
+
+    settings.type = DyFM_BasicProperty_Type.date;
+    expect(instance.getBEType()).toBe(Date);
+
+    settings.type = DyFM_BasicProperty_Type.object;
+    expect(instance.getBEType()).toBe(Object);
+
+    settings.type = 'customType[]';
+    expect(instance.getBEType()).toBe(Array);
+
+    settings.type = 'customFunction =>';
+    expect(instance.getBEType()).toBe(Function);
+  });
+});

package/src/_models/control-models/poll.control-model.spec.ts

@@ -0,0 +1,63 @@
+
+import { DyFM_Error } from './error.control-model';
+import { DyFM_Poll } from './poll.control-model';
+
+describe('DyFM_Poll', () => {
+  let pollInstance: DyFM_Poll<number>;
+  let pollDo: jasmine.Spy<(...args: any[]) => Promise<number>>;
+  let pollWhile: jasmine.Spy<(res: number) => boolean>;
+  let pollEnd: jasmine.Spy<(res: number) => void>;
+
+  beforeEach(() => {
+    pollDo = jasmine.createSpy('pollDo').and.returnValue(Promise.resolve(1));
+    pollWhile = jasmine.createSpy('pollWhile').and.returnValue(true);
+    pollEnd = jasmine.createSpy('pollEnd');
+
+    pollInstance = new DyFM_Poll<number>({
+      pollDo,
+      pollWhile,
+      pollEnd,
+      pollDelay: 0,
+      pollPeriod: 1000,
+      stopOnFail: true,
+    });
+  });
+
+  xit('should initialize with the correct properties', () => {
+    expect(pollInstance.running).toBeTrue();
+    expect(pollDo).toHaveBeenCalled();
+  });
+
+  it('should stop polling when stop is called', () => {
+    pollInstance.stop();
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should call pollEnd and stop polling when pollWhile returns false', async () => {
+    pollWhile.and.returnValue(false);
+    await pollDo.calls.mostRecent().returnValue;
+    expect(pollEnd).toHaveBeenCalledWith(1);
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should throw DyFM_Error when pollDo fails and stopOnFail is true', async () => {
+    pollDo.and.returnValue(Promise.reject('error'));
+    try {
+      await pollDo.calls.mostRecent().returnValue;
+    } catch (error) {
+      expect(error).toEqual(jasmine.any(DyFM_Error));
+    }
+    expect(pollInstance.running).toBeFalse();
+  });
+
+  xit('should restart polling with new arguments', () => {
+    const newArgs = [2];
+    pollInstance.restartPoll(newArgs);
+    expect(pollDo).toHaveBeenCalledWith(...newArgs);
+  });
+
+  xit('should restart polling with initial arguments if no new arguments are provided', () => {
+    pollInstance.restartPoll();
+    expect(pollDo).toHaveBeenCalledWith(...pollInstance['args']);
+  });
+});

package/src/_models/control-models/poll.control-model.ts

@@ -10,13 +10,14 @@ import { DyFM_Error } from './error.control-model';
 export class DyFM_Poll<T> {
   poll: Subscription;
   running: boolean;
-  private pollDo: (...args) => Promise<T>;
-  private pollWhile: (res: T) => boolean;
-  private pollEnd: (res: T) => void;
-  private args?: any[];
-  private pollDelay?: number;
-  private pollPeriod?: number;
-  private stopOnFail?: boolean;
+
+  private readonly pollDo: (...args) => Promise<T>;
+  private readonly pollWhile: (res: T) => boolean;
+  private readonly pollEnd: (res: T) => void;
+  private readonly args?: any[];
+  private readonly pollDelay?: number;
+  private readonly pollPeriod?: number;
+  private readonly stopOnFail?: boolean;
 
   constructor(
     set: {