@futdevpro/fsm-dynamo 1.16.31 → 1.16.34

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

@@ -1,352 +1,352 @@
-import { DyFM_Log } from '../../_collections/utils/log.util';
-import { DyFM_Object } from '../../_collections/utils/object.util';
-import { DyFM_getConstructionStackLocation } from '../../_collections/utils/stack.util';
-import { DyFM_getBasicPropertyType } from '../../_collections/utils/utilities.util';
-import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
-import { DyFM_DataModel_Type } from '../../_enums/data-model-type.enum';
-import { DyFM_Metadata } from '../data-models/metadata.data-model';
-import { DyFM_DataProperties, DyFM_DataProperty_Params } from './data-property-params.control-model';
-import { DyFM_Error } from './error.control-model';
-
-/**
- * FR-258 / SR-1 — declarative automatic document retention.
- *
- * When a data-model declares `retention`, `DyNTS_App` startup installs a MongoDB TTL index on
- * the record's `__created` Date field, so MongoDB NATIVELY auto-deletes documents older than the
- * configured age. This is the fleet-wide defense against the unbounded-collection-growth class:
- * a collection that grows without bound (logs / history / events / metrics / reports / archives)
- * and is then loaded by an unbounded find pulls 100s of MB into heap → GC-thrash → OOM. TTL keeps
- * the collection bounded with ZERO app-level loading.
- *
- * Declare EITHER `retentionDays` OR `ttlSeconds` (`ttlSeconds` wins if both are set).
- *
- * @example
- * ```ts
- * const params = new DyFM_DataModel_Params<MyLog>({
- *   dataName: 'my_log',
- *   retention: { retentionDays: 14 },   // auto-delete 14 days after creation
- *   properties: { ... },
- * });
- * ```
- */
-export interface DyFM_RetentionSettings {
-  /** Auto-delete documents this many days after their `__created` timestamp. */
-  retentionDays?: number;
-  /** Explicit TTL in seconds; takes precedence over `retentionDays`. */
-  ttlSeconds?: number;
-}
-
-/**
- * Resolve a {@link DyFM_RetentionSettings} to a positive integer TTL in seconds, or `undefined`
- * when no valid retention is configured (→ no TTL index is installed). `ttlSeconds` wins over
- * `retentionDays`; non-finite or ≤ 0 values are rejected. Pure + side-effect-free (unit-tested).
- */
-export function DyFM_resolveRetentionTtlSeconds(retention?: DyFM_RetentionSettings): number | undefined {
-  if (!retention) { return undefined; }
-  const raw: number | undefined =
-    retention.ttlSeconds !== undefined ? retention.ttlSeconds
-      : retention.retentionDays !== undefined ? retention.retentionDays * 86400
-        : undefined;
-  if (raw === undefined || !Number.isFinite(raw) || raw <= 0) { return undefined; }
-  return Math.floor(raw);
-}
-
-/* export type DyFM_Data_S<T extends DyFM_Metadata> = DyFM_DataModel_Settings<T>;
-export type DyFM_Data_Settings<T extends DyFM_Metadata> = DyFM_DataModel_Settings<T>; */
-export class DyFM_DataModel_Settings<T extends DyFM_Metadata> extends DyFM_Metadata {
-  /** this will be used as db table name, therefore it should be in snake_case,
-   * this also will be used in logs and errors
-   */
-  dataName!: string;
-  modelType?: DyFM_DataModel_Type;
-  
-  addArchive?: boolean;
-
-  /**
-   * If true, the Dynamo NTS will throw an error when trying to modify the data model.
-   * 
-   * @default false
-   */
-  forbidModify?: boolean;
-
-  /**
-   * If true, the Dynamo NTS will throw an error when trying to delete the data model.
-   * 
-   * @default false
-   */
-  forbidDelete?: boolean;
-
-  /**
-   * FR-258 / SR-1 — declarative automatic retention. If set, `DyNTS_App` startup creates a
-   * MongoDB TTL index on `__created`, so MongoDB auto-deletes documents older than the configured
-   * age (no app-level load → prevents the unbounded-growth → OOM class). See {@link DyFM_RetentionSettings}.
-   *
-   * @example { retentionDays: 14 }
-   */
-  retention?: DyFM_RetentionSettings;
-
-  /**
-   * from these settings we will set the data model properties for the DB.
-   * metadata properties will be added automatically to the data model.
-   */
-  properties!: DyFM_DataProperties<T>;
-}
-
-/* export type DyFM_Data_P<T extends DyFM_Metadata> = DyFM_DataModel_Params<T>;
- * 
- * @example
- * ```ts
- * const params: DyFM_DataModel_Params<DyFM_Metadata> = new DyFM_DataModel_Params({
- *   dataName: 'User',
- *   properties: {
- *     name: { type: DyFM_BasicProperty_Type.string },
- *     age: { type: DyFM_BasicProperty_Type.number },
- *   },
- * });
- */
-export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataModel_Settings<T> {
-  
-  /* override properties?: DyFM_DataProperties<T>; */
-  readonly stackLocation?: string;
-
-  constructor(
-    set: DyFM_DataModel_Settings<T>
-  ) {
-    super(set);
-
-    try {
-      if (set) {
-        Object.assign(this, set);
-      }
-  
-      this.stackLocation = DyFM_getConstructionStackLocation();
-  
-      if (!this.properties || typeof this.properties !== 'object') {
-        DyFM_Log.error(
-          'DyFM_DataModel_Params.constructor: ' +
-          `Properties are missing in "${this.dataName}" model.` +
-          `\nstackLocation: ${this.stackLocation}\n`
-        );
-  
-        this.properties = {} as DyFM_DataProperties<T>;
-      }
-  
-      const keys: string[] = Object.keys(this.properties);
-      keys.forEach((key: string): void => {
-        if (!key) {
-          DyFM_Log.error(
-            'DyFM_DataModel_Params.constructor: ' +
-            `A property key is missing in "${this.dataName}" model.` +
-            `\nstackLocation: ${this.stackLocation}\n`
-          );
-        }
-        
-        const propertyParams: DyFM_DataProperty_Params<any, T> = new DyFM_DataProperty_Params({
-          ...this.properties[key],
-          key: key,
-        }, this);
-        const basicType: DyFM_BasicProperty_Type = DyFM_getBasicPropertyType(propertyParams.type);
-        if (basicType !== propertyParams.type) {
-          propertyParams.nonBasicType = propertyParams.type;
-          propertyParams.type = basicType;
-        }
-        this.properties[key] = propertyParams;
-  
-        if (propertyParams.subObjectParams) {
-          this.setKeysForSubObjectParams(propertyParams);
-        }
-      });
-  
-      keys.forEach((key: string): void => {
-        const property: DyFM_DataProperty_Params<any, T> = this.properties[key];
-        /* if (property.vectorizeTo) {
-          if (!this.properties[property.vectorizeTo]) {
-            throw new Error(
-              `Vectorize to property "${property.vectorizeTo}" is not found in ` +
-              `"${this.dataName}" model.`
-            );
-          }
-  
-          this.properties[property.vectorizeTo].vectorizeFrom ??= key;
-        } */
-  
-        if (property.vectorizedFrom) {
-          property.vectorizedFrom.forEach((fromKey: string): void => {
-            if (!this.properties[fromKey]) {
-              DyFM_Log.error(
-                `Vectorized from property "${fromKey}" is not found in ` +
-                `"${this.dataName}" model.` +
-                `\nstackLocation: ${this.stackLocation}\n`
-              );
-            }
-  
-            /* if (!this.properties[fromKey].vectorizeUseIndex) {
-              DyFM_Log.error(
-                `Vectorized from property "${fromKey}" has no vectorizeUseIndex in ` +
-                `"${this.dataName}" model.` +
-                `\nstackLocation: ${this.stackLocation}\n`
-              );
-            } */
-  
-            /* if (
-              (this.properties[fromKey] as DyFM_DataProperty_Params<any>)?.type !== DyFM_BasicProperty_Type.string
-            ) {
-              DyFM_Log.error(
-                `Vectorized from property "${property.vectorizedFrom}" is not a string property in ` +
-                `"${this.dataName}" model.` +
-                `\nstackLocation: ${this.stackLocation}\n`
-              );
-            } */
-          });
-  
-          /* this.properties[property.vectorizedFrom].vectorizeTo ??= key; */
-  
-          if (property.type !== DyFM_BasicProperty_Type.array) {
-            DyFM_Log.error(
-              `Vectorized from property "${property.vectorizedFrom}" is not a number[] property in ` +
-              `"${this.dataName}" model.` +
-              `\nstackLocation: ${this.stackLocation}\n`
-            );
-          }
-
-          if (property.nonBasicType !== 'number[]') {
-            DyFM_Log.error(
-              `Vectorized from property "${property.vectorizedFrom}" is not a number[] property in ` +
-              `"${this.dataName}" model.` +
-              `\nstackLocation: ${this.stackLocation}\n`
-            );
-          }
-  
-          if (!property.vectorizeUseIndex) {
-            DyFM_Log.error(
-              'vectorizeUseIndex is required if vectorizedFrom is set. ' +
-              `"${this.dataName}" model.` +
-              `\nstackLocation: ${this.stackLocation}\n`
-            );
-          }
-  
-          if (property.index) {
-            /** {@link DyFM_DataProperty_Params.vectorizeUseIndex} */
-            DyFM_Log.warn(
-              `index is not recommended to be set for vectorized properties in ` +
-              `"${this.dataName}" model. ` +
-              `\n(you should set it in the Atlas and vectorizeUseIndex, ` +
-              `more info at DyFM_DataProperty_Params.vectorizeUseIndex))` +
-              `\nstackLocation: ${this.stackLocation}\n`
-            );
-          }
-  
-          /* if (!this.properties[property.vectorizeUseIndex]) {
-            throw new Error(
-              `vectorizeUseIndex property "${property.vectorizeUseIndex}" is not found in ` +
-              `"${this.dataName}" model.` +
-              `\nstackLocation: ${this.stackLocation}\n`
-            );
-          }
-  
-          if (!(this.properties[property.vectorizeUseIndex] as DyFM_DataProperty_Params<any>).index) {
-            throw new Error(
-              `vectorizeUseIndex property "${property.vectorizeUseIndex}" is not an ` +
-              `index property in "${this.dataName}" model.` +
-              `\nstackLocation: ${this.stackLocation}`
-            );
-          } */
-        }
-      });
-  
-      if (!this?.modelType || this?.modelType == DyFM_DataModel_Type.data) {
-        this.modelType = DyFM_DataModel_Type.data;
-      }
-  
-      /* if (!this.dbName && this?.modelType == DyFM_DataModel_Type.data) {
-        // upper case first letter
-        this.dbName = this.dataName.charAt(0).toUpperCase() + this.dataName.slice(1);
-        
-        this.dbName.split('').forEach((char: string, index: number): void => {
-          if (
-            index > 0 && 
-            this.dbName[index - 1] === '_' && 
-            char === char.toUpperCase()
-          ) {
-            this.dbName = this.dbName.slice(0, index) + 
-                          char.toLowerCase() + 
-                          this.dbName.slice(index + 1);
-          }
-        });
-      } */
-  
-      if (!this.dataName) {
-        DyFM_Log.error(
-          'DyFM_DataModel_Params.constructor: ' +
-          `dataName is missing in "${this.dataName}" model.` +
-          `\nstackLocation: ${this.stackLocation}\n`
-        );
-        this.dataName = 'UNNAMED_MODEL';
-      }
-  
-      // check for any Uppercase letters in dbName (not needed cos can be DyNAny_something_like_this)
-      /* if (RegExp(/[A-Z]/).exec(this.dataName)) {
-        DyFM_Log.warn(
-          'DyFM_DataModel_Params.constructor: ' +
-          `dbName should be in snake_case in "${this.dataName}" model.` +
-          'For future compatibility.' +
-          `\nstackLocation: ${this.stackLocation}\n`
-        );
-      } */
-  
-      if (this.dataName.includes('-')) {
-        DyFM_Log.warn(
-          'DyFM_DataModel_Params.constructor: ' +
-          `dataName should be in snake_case in "${this.dataName}" model.` +
-          'For future compatibility.' +
-          `\nstackLocation: ${this.stackLocation}\n`
-        );
-      }
-
-      DyFM_Object.cleanObject(this);
-    } catch (error) {
-      DyFM_Error.logSimple('DyFM_DataModel_Params.constructor error:', error);
-      DyFM_Log.warn(
-        'Due to the error, the Params contruction failed, therefore the model is not constructed properly. ' +
-        `("${this.dataName}" model)` +
-        `\nstackLocation: ${this.stackLocation}`
-      );
-      /* DyFM_Log.error(
-        'DyFM_DataModel_Params.constructor: ' +
-        `An error occurred while constructing the "${this.dataName}" model.` +
-        `\nstackLocation: ${this.stackLocation}\n`
-      ); */
-    }
-  }
-
-  constructed?(): boolean { 
-    return true; 
-  }
-
-  setKeysForSubObjectParams?(property: DyFM_DataProperty_Params<any, T>): void {
-    if (property.subObjectParams) {
-      Object.keys(property.subObjectParams).forEach((key: string): void => {
-        if (!key) {
-          DyFM_Log.error(
-            'DyFM_DataModel_Params.setKeysForSubObjectParams: ' +
-            `A subObjectParams key is missing in "${this.dataName}" model.` +
-            `\nstackLocation: ${this.stackLocation}\n`
-          );
-        }
-
-        const subObjectPropertyParams: DyFM_DataProperty_Params<any, T> = property.subObjectParams[key];
-
-        subObjectPropertyParams.key = key;
-        const basicType: DyFM_BasicProperty_Type = DyFM_getBasicPropertyType(subObjectPropertyParams.type);
-        if (basicType !== subObjectPropertyParams.type) {
-          subObjectPropertyParams.nonBasicType = subObjectPropertyParams.type;
-          subObjectPropertyParams.type = basicType;
-        }
-
-        if (subObjectPropertyParams.subObjectParams) {
-          this.setKeysForSubObjectParams(subObjectPropertyParams);
-        }
-      });
-    }
-  }
-}
+import { DyFM_Log } from '../../_collections/utils/log.util';
+import { DyFM_Object } from '../../_collections/utils/object.util';
+import { DyFM_getConstructionStackLocation } from '../../_collections/utils/stack.util';
+import { DyFM_getBasicPropertyType } from '../../_collections/utils/utilities.util';
+import { DyFM_BasicProperty_Type } from '../../_enums/basic-property-type.enum';
+import { DyFM_DataModel_Type } from '../../_enums/data-model-type.enum';
+import { DyFM_Metadata } from '../data-models/metadata.data-model';
+import { DyFM_DataProperties, DyFM_DataProperty_Params } from './data-property-params.control-model';
+import { DyFM_Error } from './error.control-model';
+
+/**
+ * FR-258 / SR-1 — declarative automatic document retention.
+ *
+ * When a data-model declares `retention`, `DyNTS_App` startup installs a MongoDB TTL index on
+ * the record's `__created` Date field, so MongoDB NATIVELY auto-deletes documents older than the
+ * configured age. This is the fleet-wide defense against the unbounded-collection-growth class:
+ * a collection that grows without bound (logs / history / events / metrics / reports / archives)
+ * and is then loaded by an unbounded find pulls 100s of MB into heap → GC-thrash → OOM. TTL keeps
+ * the collection bounded with ZERO app-level loading.
+ *
+ * Declare EITHER `retentionDays` OR `ttlSeconds` (`ttlSeconds` wins if both are set).
+ *
+ * @example
+ * ```ts
+ * const params = new DyFM_DataModel_Params<MyLog>({
+ *   dataName: 'my_log',
+ *   retention: { retentionDays: 14 },   // auto-delete 14 days after creation
+ *   properties: { ... },
+ * });
+ * ```
+ */
+export interface DyFM_RetentionSettings {
+  /** Auto-delete documents this many days after their `__created` timestamp. */
+  retentionDays?: number;
+  /** Explicit TTL in seconds; takes precedence over `retentionDays`. */
+  ttlSeconds?: number;
+}
+
+/**
+ * Resolve a {@link DyFM_RetentionSettings} to a positive integer TTL in seconds, or `undefined`
+ * when no valid retention is configured (→ no TTL index is installed). `ttlSeconds` wins over
+ * `retentionDays`; non-finite or ≤ 0 values are rejected. Pure + side-effect-free (unit-tested).
+ */
+export function DyFM_resolveRetentionTtlSeconds(retention?: DyFM_RetentionSettings): number | undefined {
+  if (!retention) { return undefined; }
+  const raw: number | undefined =
+    retention.ttlSeconds !== undefined ? retention.ttlSeconds
+      : retention.retentionDays !== undefined ? retention.retentionDays * 86400
+        : undefined;
+  if (raw === undefined || !Number.isFinite(raw) || raw <= 0) { return undefined; }
+  return Math.floor(raw);
+}
+
+/* export type DyFM_Data_S<T extends DyFM_Metadata> = DyFM_DataModel_Settings<T>;
+export type DyFM_Data_Settings<T extends DyFM_Metadata> = DyFM_DataModel_Settings<T>; */
+export class DyFM_DataModel_Settings<T extends DyFM_Metadata> extends DyFM_Metadata {
+  /** this will be used as db table name, therefore it should be in snake_case,
+   * this also will be used in logs and errors
+   */
+  dataName!: string;
+  modelType?: DyFM_DataModel_Type;
+  
+  addArchive?: boolean;
+
+  /**
+   * If true, the Dynamo NTS will throw an error when trying to modify the data model.
+   * 
+   * @default false
+   */
+  forbidModify?: boolean;
+
+  /**
+   * If true, the Dynamo NTS will throw an error when trying to delete the data model.
+   * 
+   * @default false
+   */
+  forbidDelete?: boolean;
+
+  /**
+   * FR-258 / SR-1 — declarative automatic retention. If set, `DyNTS_App` startup creates a
+   * MongoDB TTL index on `__created`, so MongoDB auto-deletes documents older than the configured
+   * age (no app-level load → prevents the unbounded-growth → OOM class). See {@link DyFM_RetentionSettings}.
+   *
+   * @example { retentionDays: 14 }
+   */
+  retention?: DyFM_RetentionSettings;
+
+  /**
+   * from these settings we will set the data model properties for the DB.
+   * metadata properties will be added automatically to the data model.
+   */
+  properties!: DyFM_DataProperties<T>;
+}
+
+/* export type DyFM_Data_P<T extends DyFM_Metadata> = DyFM_DataModel_Params<T>;
+ * 
+ * @example
+ * ```ts
+ * const params: DyFM_DataModel_Params<DyFM_Metadata> = new DyFM_DataModel_Params({
+ *   dataName: 'User',
+ *   properties: {
+ *     name: { type: DyFM_BasicProperty_Type.string },
+ *     age: { type: DyFM_BasicProperty_Type.number },
+ *   },
+ * });
+ */
+export class DyFM_DataModel_Params<T extends DyFM_Metadata> extends DyFM_DataModel_Settings<T> {
+  
+  /* override properties?: DyFM_DataProperties<T>; */
+  readonly stackLocation?: string;
+
+  constructor(
+    set: DyFM_DataModel_Settings<T>
+  ) {
+    super(set);
+
+    try {
+      if (set) {
+        Object.assign(this, set);
+      }
+  
+      this.stackLocation = DyFM_getConstructionStackLocation();
+  
+      if (!this.properties || typeof this.properties !== 'object') {
+        DyFM_Log.error(
+          'DyFM_DataModel_Params.constructor: ' +
+          `Properties are missing in "${this.dataName}" model.` +
+          `\nstackLocation: ${this.stackLocation}\n`
+        );
+  
+        this.properties = {} as DyFM_DataProperties<T>;
+      }
+  
+      const keys: string[] = Object.keys(this.properties);
+      keys.forEach((key: string): void => {
+        if (!key) {
+          DyFM_Log.error(
+            'DyFM_DataModel_Params.constructor: ' +
+            `A property key is missing in "${this.dataName}" model.` +
+            `\nstackLocation: ${this.stackLocation}\n`
+          );
+        }
+        
+        const propertyParams: DyFM_DataProperty_Params<any, T> = new DyFM_DataProperty_Params({
+          ...this.properties[key],
+          key: key,
+        }, this);
+        const basicType: DyFM_BasicProperty_Type = DyFM_getBasicPropertyType(propertyParams.type);
+        if (basicType !== propertyParams.type) {
+          propertyParams.nonBasicType = propertyParams.type;
+          propertyParams.type = basicType;
+        }
+        this.properties[key] = propertyParams;
+  
+        if (propertyParams.subObjectParams) {
+          this.setKeysForSubObjectParams(propertyParams);
+        }
+      });
+  
+      keys.forEach((key: string): void => {
+        const property: DyFM_DataProperty_Params<any, T> = this.properties[key];
+        /* if (property.vectorizeTo) {
+          if (!this.properties[property.vectorizeTo]) {
+            throw new Error(
+              `Vectorize to property "${property.vectorizeTo}" is not found in ` +
+              `"${this.dataName}" model.`
+            );
+          }
+  
+          this.properties[property.vectorizeTo].vectorizeFrom ??= key;
+        } */
+  
+        if (property.vectorizedFrom) {
+          property.vectorizedFrom.forEach((fromKey: string): void => {
+            if (!this.properties[fromKey]) {
+              DyFM_Log.error(
+                `Vectorized from property "${fromKey}" is not found in ` +
+                `"${this.dataName}" model.` +
+                `\nstackLocation: ${this.stackLocation}\n`
+              );
+            }
+  
+            /* if (!this.properties[fromKey].vectorizeUseIndex) {
+              DyFM_Log.error(
+                `Vectorized from property "${fromKey}" has no vectorizeUseIndex in ` +
+                `"${this.dataName}" model.` +
+                `\nstackLocation: ${this.stackLocation}\n`
+              );
+            } */
+  
+            /* if (
+              (this.properties[fromKey] as DyFM_DataProperty_Params<any>)?.type !== DyFM_BasicProperty_Type.string
+            ) {
+              DyFM_Log.error(
+                `Vectorized from property "${property.vectorizedFrom}" is not a string property in ` +
+                `"${this.dataName}" model.` +
+                `\nstackLocation: ${this.stackLocation}\n`
+              );
+            } */
+          });
+  
+          /* this.properties[property.vectorizedFrom].vectorizeTo ??= key; */
+  
+          if (property.type !== DyFM_BasicProperty_Type.array) {
+            DyFM_Log.error(
+              `Vectorized from property "${property.vectorizedFrom}" is not a number[] property in ` +
+              `"${this.dataName}" model.` +
+              `\nstackLocation: ${this.stackLocation}\n`
+            );
+          }
+
+          if (property.nonBasicType !== 'number[]') {
+            DyFM_Log.error(
+              `Vectorized from property "${property.vectorizedFrom}" is not a number[] property in ` +
+              `"${this.dataName}" model.` +
+              `\nstackLocation: ${this.stackLocation}\n`
+            );
+          }
+  
+          if (!property.vectorizeUseIndex) {
+            DyFM_Log.error(
+              'vectorizeUseIndex is required if vectorizedFrom is set. ' +
+              `"${this.dataName}" model.` +
+              `\nstackLocation: ${this.stackLocation}\n`
+            );
+          }
+  
+          if (property.index) {
+            /** {@link DyFM_DataProperty_Params.vectorizeUseIndex} */
+            DyFM_Log.warn(
+              `index is not recommended to be set for vectorized properties in ` +
+              `"${this.dataName}" model. ` +
+              `\n(you should set it in the Atlas and vectorizeUseIndex, ` +
+              `more info at DyFM_DataProperty_Params.vectorizeUseIndex))` +
+              `\nstackLocation: ${this.stackLocation}\n`
+            );
+          }
+  
+          /* if (!this.properties[property.vectorizeUseIndex]) {
+            throw new Error(
+              `vectorizeUseIndex property "${property.vectorizeUseIndex}" is not found in ` +
+              `"${this.dataName}" model.` +
+              `\nstackLocation: ${this.stackLocation}\n`
+            );
+          }
+  
+          if (!(this.properties[property.vectorizeUseIndex] as DyFM_DataProperty_Params<any>).index) {
+            throw new Error(
+              `vectorizeUseIndex property "${property.vectorizeUseIndex}" is not an ` +
+              `index property in "${this.dataName}" model.` +
+              `\nstackLocation: ${this.stackLocation}`
+            );
+          } */
+        }
+      });
+  
+      if (!this?.modelType || this?.modelType == DyFM_DataModel_Type.data) {
+        this.modelType = DyFM_DataModel_Type.data;
+      }
+  
+      /* if (!this.dbName && this?.modelType == DyFM_DataModel_Type.data) {
+        // upper case first letter
+        this.dbName = this.dataName.charAt(0).toUpperCase() + this.dataName.slice(1);
+        
+        this.dbName.split('').forEach((char: string, index: number): void => {
+          if (
+            index > 0 && 
+            this.dbName[index - 1] === '_' && 
+            char === char.toUpperCase()
+          ) {
+            this.dbName = this.dbName.slice(0, index) + 
+                          char.toLowerCase() + 
+                          this.dbName.slice(index + 1);
+          }
+        });
+      } */
+  
+      if (!this.dataName) {
+        DyFM_Log.error(
+          'DyFM_DataModel_Params.constructor: ' +
+          `dataName is missing in "${this.dataName}" model.` +
+          `\nstackLocation: ${this.stackLocation}\n`
+        );
+        this.dataName = 'UNNAMED_MODEL';
+      }
+  
+      // check for any Uppercase letters in dbName (not needed cos can be DyNAny_something_like_this)
+      /* if (RegExp(/[A-Z]/).exec(this.dataName)) {
+        DyFM_Log.warn(
+          'DyFM_DataModel_Params.constructor: ' +
+          `dbName should be in snake_case in "${this.dataName}" model.` +
+          'For future compatibility.' +
+          `\nstackLocation: ${this.stackLocation}\n`
+        );
+      } */
+  
+      if (this.dataName.includes('-')) {
+        DyFM_Log.warn(
+          'DyFM_DataModel_Params.constructor: ' +
+          `dataName should be in snake_case in "${this.dataName}" model.` +
+          'For future compatibility.' +
+          `\nstackLocation: ${this.stackLocation}\n`
+        );
+      }
+
+      DyFM_Object.cleanObject(this);
+    } catch (error) {
+      DyFM_Error.logSimple('DyFM_DataModel_Params.constructor error:', error);
+      DyFM_Log.warn(
+        'Due to the error, the Params contruction failed, therefore the model is not constructed properly. ' +
+        `("${this.dataName}" model)` +
+        `\nstackLocation: ${this.stackLocation}`
+      );
+      /* DyFM_Log.error(
+        'DyFM_DataModel_Params.constructor: ' +
+        `An error occurred while constructing the "${this.dataName}" model.` +
+        `\nstackLocation: ${this.stackLocation}\n`
+      ); */
+    }
+  }
+
+  constructed?(): boolean { 
+    return true; 
+  }
+
+  setKeysForSubObjectParams?(property: DyFM_DataProperty_Params<any, T>): void {
+    if (property.subObjectParams) {
+      Object.keys(property.subObjectParams).forEach((key: string): void => {
+        if (!key) {
+          DyFM_Log.error(
+            'DyFM_DataModel_Params.setKeysForSubObjectParams: ' +
+            `A subObjectParams key is missing in "${this.dataName}" model.` +
+            `\nstackLocation: ${this.stackLocation}\n`
+          );
+        }
+
+        const subObjectPropertyParams: DyFM_DataProperty_Params<any, T> = property.subObjectParams[key];
+
+        subObjectPropertyParams.key = key;
+        const basicType: DyFM_BasicProperty_Type = DyFM_getBasicPropertyType(subObjectPropertyParams.type);
+        if (basicType !== subObjectPropertyParams.type) {
+          subObjectPropertyParams.nonBasicType = subObjectPropertyParams.type;
+          subObjectPropertyParams.type = basicType;
+        }
+
+        if (subObjectPropertyParams.subObjectParams) {
+          this.setKeysForSubObjectParams(subObjectPropertyParams);
+        }
+      });
+    }
+  }
+}