@futdevpro/nts-dynamo 1.11.37 → 1.11.39

package/src/_modules/open-ai/_services/oai-vector-data.service.ts

@@ -58,8 +58,8 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
    * Properties that are vectorized
    * (properties that are marked with vectorizeFrom in other properties)
    */
-  readonly vectorizeProperties: DyFM_DataProperty_Params<any>[];
-  readonly vectorizedProperties: DyFM_DataProperty_Params<any>[];
+  readonly vectorizeProperties: DyFM_DataProperty_Params<any, T>[];
+  readonly vectorizedProperties: DyFM_DataProperty_Params<any, T>[];
   /* readonly vectorizeProperties: { from: string, to: string }[]; */
 
   debugLog: boolean = true;
@@ -88,15 +88,15 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
     super(data, dataParams, issuer);
 
     this.vectorizedProperties = Object.values(dataParams.properties).filter(
-      (property: DyFM_DataProperty_Params<any>) => property.vectorizedFrom
+      (property: DyFM_DataProperty_Params<any, T>) => property.vectorizedFrom
     );
 
     this.vectorizeProperties = Object.keys(dataParams.properties).filter(
       (key: string): boolean => this.vectorizedProperties.some(
-        (property: DyFM_DataProperty_Params<any>) => property.vectorizedFrom.includes(key)
+        (property: DyFM_DataProperty_Params<any, T>) => property.vectorizedFrom.includes(key)
       )
     ).map(
-      (key: string): DyFM_DataProperty_Params<any> => dataParams.properties[key] as DyFM_DataProperty_Params<any>
+      (key: string): DyFM_DataProperty_Params<any, T> => dataParams.properties[key] as DyFM_DataProperty_Params<any, T>
     );
     
     /* const vectorizePropertyKeys: string[] = Object.keys(dataParams.properties).filter(
@@ -134,7 +134,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
         'vectorizedProperties is missing! ' +
         `\nkeys with vectorizedFrom: ${Object.keys(dataParams.properties).filter(
           (key: string): boolean => Boolean(
-            (dataParams.properties[key] as DyFM_DataProperty_Params<any>).vectorizedFrom
+            (dataParams.properties[key] as DyFM_DataProperty_Params<any, T>).vectorizedFrom
           )
         ).map(key => `"${key}"`).join(', ')}`
       );
@@ -145,7 +145,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
         'vectorizeProperties is missing! ' +
         `\nkeys with vectorizeFrom: ${Object.keys(dataParams.properties).filter(
           (key: string): boolean => Boolean(
-            (dataParams.properties[key] as DyFM_DataProperty_Params<any>).vectorizedFrom
+            (dataParams.properties[key] as DyFM_DataProperty_Params<any, T>).vectorizedFrom
           )
         ).map(key => `"${key}"`).join(', ')}`
       );
@@ -166,7 +166,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
       dataParams.properties[key].embeddingModel ??= model;
     }); */
 
-    this.vectorizedProperties.forEach((property: DyFM_DataProperty_Params<any>): void => {
+    this.vectorizedProperties.forEach((property: DyFM_DataProperty_Params<any, T>): void => {
       property.embeddingModel ??= model;
     });
 
@@ -196,7 +196,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
 
       await DyFM_Array.asyncForEachAllAtOnce(
         this.vectorizedProperties,
-        async (property: DyFM_DataProperty_Params<any>) => {
+        async (property: DyFM_DataProperty_Params<any, T>) => {
           await this.checkAndVectorizeSingleProperty(property, newData, existingData, forceVectorize);
         }
       );
@@ -210,7 +210,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
   }
 
   private async checkAndVectorizeSingleProperty(
-    vectorizedProperty: DyFM_DataProperty_Params<any>,
+    vectorizedProperty: DyFM_DataProperty_Params<any, T>,
     newData: T,
     existingData: T,
     forceVectorize?: boolean
@@ -257,7 +257,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
   }
 
   private async getVectorizingDataForVectorizedProperty(
-    vectorizedProperty: DyFM_DataProperty_Params<any>,
+    vectorizedProperty: DyFM_DataProperty_Params<any, T>,
     data: T,
     /* alwaysVectorize?: boolean */
   ): Promise<string> {
@@ -361,7 +361,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
         this.openAISettings
       );
 
-      const property: DyFM_DataProperty_Params<any> = this.dataParams.properties[searchInKey];
+      const property: DyFM_DataProperty_Params<any, T> = this.dataParams.properties[searchInKey];
 
       if (!property) {
         throw new DyFM_Error({
@@ -449,7 +449,7 @@ export class DyNTS_OAI_VectorDataService<T extends DyFM_Metadata> extends DyNTS_
       data = await super.saveData(data, dontSetToService);
 
       if (this.swallowVectorizedProperties) {
-        this.vectorizedProperties.forEach((property: DyFM_DataProperty_Params<any>): void => {
+        this.vectorizedProperties.forEach((property: DyFM_DataProperty_Params<any, T>): void => {
           delete data[property.key];
         });
       }

package/src/_services/base/data.service.ts

@@ -3,8 +3,8 @@ import {
   DyFM_AnyError,
   DyFM_Array,
   DyFM_BasicProperty_Type,
-  DyFM_Data_Params,
   DyFM_DataModel_Params,
+  DyFM_DataProperties,
   DyFM_DataProperty_Params,
   DyFM_DBFilter,
   DyFM_DBĐNestedPropertySort,
@@ -91,7 +91,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
      * DB data prams will be used to connect to usable dbService on GlobalService
      */
     /* dataParams: DyFM_DataModel_Params, */
-    public dataParams: DyFM_Data_Params<T>,
+    public dataParams: DyFM_DataModel_Params<T>,
     /**
      * Initial set for issuer to be able to follow the issuer's activity
      */
@@ -1180,83 +1180,273 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     try {
       data = this.ensureData(data);
 
-      Object.values(this.dataParams.properties).forEach(
-        (element: DyFM_DataProperty_Params<any>) => {
-          // basic required validations
-          if (
-            (
-              element.required ||
-              element.index
-            ) && (
-              data[element.key] === null || 
-              data[element.key] === undefined
-            )
-          ) {
-            throw new DyFM_Error({ 
-              ...this._getDefaultErrorSettings(
-                'validateForSave',
-                new Error(
-                  `validateForSave failed, "${element.key}" is missing! ` +
-                  `(index or required in "${this.dataParams.dataName}" dataParams) `
-                )
-              ),
-
-              status: 522, 
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD1`,
-              userMessage: this.defaultValidationErrorUserMsg,
-              __localStack: this.dataParams.stackLocation,
-              additionalContent: {
-                data: data,
-              },
-            });
-          }
-
-          // specific Date validation
-          if (element.type === 'Date' && 
-            !(new Date(data[element.key]) instanceof Date)
-          ) {
-            throw new DyFM_Error({
-              ...this._getDefaultErrorSettings(
-                'validateForSave',
-                new Error(
-                  `validateForSave failed, "${element.key}" is not a date! ` +
-                  `(${this.dataParams.dataName})`
-                )
-              ),
+      await this.validateDataByPropertyParams(data, this.dataParams.properties);
+    } catch (error) {
+      if (error?.errorCode?.includes?.('DyNTS-DS0-VBP') || error?.errorCode?.includes?.('DyNTS-DS0-VP')) {
+        throw error;
+      } else {
+        throw new DyFM_Error({ 
+          ...this._getDefaultErrorSettings('validateForSave', error),
 
-              status: 522, 
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD2`,
-              userMessage: this.defaultValidationErrorUserMsg,
-              __localStack: this.dataParams.stackLocation,
-              additionalContent: {
-                data: data,
-              },
-            });
-          }
+          status: 522, 
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD0`,
+        });
+      }
+    }
+  }
 
-          // call additional validators
-          if (element.additionalValidators) {
-            for (let j = 0; j < element.additionalValidators.length; j++) {
-              element.additionalValidators[j](
-                data[element.key]
-              );
-            }
-          }
+  private validateDataByPropertyParams(
+    data: T, 
+    properties: DyFM_DataProperties<T>,
+    isSubObjectOf?: DyFM_DataProperty_Params<any, T>
+  ): void {
+    try {
+      Object.values(properties).forEach(
+        (propertyParams: DyFM_DataProperty_Params<any, T>) => {
+          this.validateProperty(data, data[propertyParams.key], propertyParams, isSubObjectOf);
         }
       );
     } catch (error) {
-      if ([ 
-        `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD1`, 
-        `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD2` 
-      ].includes(error?.errorCode)) {
+      if (error?.errorCode?.includes?.('DyNTS-DS0-VP')) {
         throw error;
       } else {
         throw new DyFM_Error({ 
-          ...this._getDefaultErrorSettings('validateForSave', error),
+          ...this._getDefaultErrorSettings('validateByPropertyParams', error),
 
           status: 522, 
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD0`,
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP0`,
+        });
+      }
+    }
+  }
+
+  private validateProperty(
+    data: T, 
+    propertyValue: any,
+    propertyParams: DyFM_DataProperty_Params<any, T>,
+    isSubObjectOf?: DyFM_DataProperty_Params<any, T>
+  ): void {
+    
+    // basic required validations
+    if (
+      (
+        propertyParams.required ||
+        propertyParams.index
+      ) && (
+        propertyValue === null || 
+        propertyValue === undefined
+      )
+    ) {
+      throw new DyFM_Error({ 
+        ...this._getDefaultErrorSettings(
+          'validateProperty',
+          new Error(
+            `validateProperty failed, "${propertyParams.key}" is missing! ` +
+            `(index or required in "${this.dataParams.dataName}" dataParams) `
+          )
+        ),
+
+        status: 522, 
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP1`,
+        userMessage: this.defaultValidationErrorUserMsg,
+        __localStack: this.dataParams.stackLocation,
+        additionalContent: {
+          data: data,
+        },
+      });
+    }
+
+    // specific Date validation
+    switch (propertyParams.type) {
+      case DyFM_BasicProperty_Type.date:
+        const date = new Date(propertyValue);
+        if (
+          propertyParams.required && (
+            !(date instanceof Date) ||
+            date.toString() === 'Invalid Date' ||
+            isNaN(date.getTime()) ||
+            date.toString() === new Date(0).toString()
+          )
+        ) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid date! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP2`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+            additionalContent: {
+              data: data,
+            },
+          });
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.number:
+        if (propertyParams.required && isNaN(propertyValue)) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid number! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP3`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+            additionalContent: {
+              data: data,
+            },
+          });
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.string:
+        if (propertyParams.required && typeof propertyValue !== 'string') {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid string! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP4`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+            additionalContent: {
+              data: data,
+            },
+          });
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.boolean:
+        if (propertyParams.required && typeof propertyValue !== 'boolean') {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid boolean! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP5`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+          });
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.object:
+        if (propertyParams.required && typeof propertyValue !== 'object') {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid object! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VD6`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+          });
+        }
+
+        if (propertyParams.subObjectParams) {
+          this.validateDataByPropertyParams(propertyValue, propertyParams.subObjectParams, propertyParams);
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.array:
+        if (propertyParams.required && !Array.isArray(propertyValue)) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid array! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP7`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+          });
+        }
+
+        if (propertyParams.subObjectParams) {
+          propertyValue.forEach((item: any): void => {
+            this.validateDataByPropertyParams(item, propertyParams.subObjectParams, propertyParams);
+          });
+        }
+        break;
+
+      case DyFM_BasicProperty_Type.function:
+        DyFM_Log.warn(
+          'validateProperty: function type is not supported yet! ' +
+            '(it will be skipped, but you still can use it in additionalValidators)'
+        );
+          /* if (propertyParams.required && typeof propertyValue !== 'function') {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'validateProperty',
+              new Error(
+                `validateProperty failed, "${propertyParams.key}" is not a valid function! ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
+
+            status: 522, 
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP7`,
+            userMessage: this.defaultValidationErrorUserMsg,
+            __localStack: this.dataParams.stackLocation,
+          });
+        } */
+        break;
+
+      default:
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'validateProperty',
+            new Error(
+              `validateProperty failed, "${propertyParams.key}" is not a valid property type! ` +
+              `(type: ${propertyParams.type}, nonBasicType: ${propertyParams.nonBasicType}) ` +
+              `(${this.dataParams.dataName})`
+            )
+          ),
+
+          status: 522, 
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DS0-VP8`,
+          userMessage: this.defaultValidationErrorUserMsg,
+          __localStack: this.dataParams.stackLocation,
         });
+    }
+
+    // call additional validators
+    if (propertyParams.additionalValidators) {
+      for (let j = 0; j < propertyParams.additionalValidators.length; j++) {
+        propertyParams.additionalValidators[j](
+          propertyValue,
+          data
+        );
       }
     }
   }
@@ -1906,9 +2096,9 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
    * setting up dependency dataHook by DynamoBEDataModelParams
    */
   private lookForDependencyDataSettings(): void {
-    const dependencyParams: DyFM_DataProperty_Params<any>[] = 
+    const dependencyParams: DyFM_DataProperty_Params<any, T>[] = 
       Object.values(this.dataParams.properties).filter(
-        (modelParams: DyFM_DataProperty_Params<any>): boolean => 
+        (modelParams: DyFM_DataProperty_Params<any, T>): boolean => 
           Boolean(modelParams.dependencyDataName)
       );
 

package/src/_services/base/db.service.ts

@@ -4,6 +4,7 @@ import { Schema } from 'mongoose';
 
 import {
   DyFM_AnyError,
+  DyFM_BasicProperty_Type,
   DyFM_DataModel_Params,
   DyFM_DataProperties,
   DyFM_DataProperty_Params,
@@ -11,7 +12,8 @@ import {
   DyFM_Error,
   DyFM_Error_Settings, DyFM_ErrorLevel,
   DyFM_Log,
-  DyFM_Metadata
+  DyFM_Metadata,
+  DyFM_Object
 } from '@futdevpro/fsm-dynamo';
 import { DyNTS_archiveSuffix } from '../../_collections/archive.util';
 import { DyNTS_DBUpdate } from '../../_models/types/db-update.type';
@@ -51,6 +53,18 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         );
       }
 
+      if (!this.dataParams.constructed?.()) {
+        throw new DyFM_Error({
+          error: new Error(
+            `DataModelParams is not constructed properly! (${this.dataParams.dataName}) ` +
+            `Use the DyFM_DataModel_Params.constructor to construct it properly! (NTS DB)`
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DBS-C01`,
+          additionalContent: { dataParams: this.dataParams },
+          __localStack: this.dataParams.stackLocation,
+        });
+      }
+
       try {
         this.dataModel = mongoose.model(this.dataParams.dataName, this.getSchema());
       } catch (error) {
@@ -644,7 +658,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     }
 
     Object.values(this.dataParams.properties).forEach(
-      (modelParam: DyFM_DataProperty_Params<any>): void => {
+      (modelParam: DyFM_DataProperty_Params<any, T>): void => {
         if (
           (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) || 
           filterBy[modelParam.key + 'Range']
@@ -1215,7 +1229,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
       properties = this.dataParams.properties;
     } */
 
-    Object.values(properties).forEach((property: DyFM_DataProperty_Params<any>): void => {
+    Object.values(properties).forEach((property: DyFM_DataProperty_Params<any, T>): void => {
       if (!property) {
         DyFM_Log.warn(`property is undefined on ${this.dataParams.dataName} (NTS DB)`);
         
@@ -1239,7 +1253,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         });
       }
 
-      const beType = this.getBEType(property.type);
+      const beType = this.getBEType(property.type as DyFM_BasicProperty_Type);
 
       /* TODO if (beType === Array && property.archiveable && !property.archiveListAfter) {
         property.archiveListAfter = DyNTS_global_settings.archiveListAfter;
@@ -1285,24 +1299,68 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   }
 
   private getBEType(
-    type: string
+    type: DyFM_BasicProperty_Type
   ): string | number | boolean | object | Function | Array<any> | Date {
-    switch (type.toLocaleLowerCase()) {
+    switch (type) {
+      case DyFM_BasicProperty_Type.string:
+        return String;
+
+      case DyFM_BasicProperty_Type.number:
+        return Number;
+
+      case DyFM_BasicProperty_Type.boolean:
+        return Boolean;
+
+      case DyFM_BasicProperty_Type.date:
+        return Date;
+
+      case DyFM_BasicProperty_Type.object:
+        return Object;
+
+      case DyFM_BasicProperty_Type.array:
+        return Array;
+
+      case DyFM_BasicProperty_Type.function:
+        return Function;
 
+      default:
+        DyFM_Log.H_info('wtf', DyFM_Object.cleanObject(this.dataParams));
+
+        throw new DyFM_Error({
+          error: new Error(
+            `Invalid property type: ${type} (${this.dataParams.dataName})` +
+            (this.dataParams.constructed?.() ? '' : ('\nThe dataParams is not constructed properly! \n' +
+              'Use the DyFM_DataModel_Params.constructor to construct it properly!'))
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DBS-GTP0`,
+          additionalContent: { type: type, dataParams: this.dataParams },
+          __localStack: this.dataParams.stackLocation,
+        });
+    }
+    /* switch (type.toLocaleLowerCase()) {
+      case DyFM_BasicProperty_Type.string:
       case 'string':
         return String;
         
+      case DyFM_BasicProperty_Type.number:
       case 'number':
         return Number;
 
+      case DyFM_BasicProperty_Type.boolean:
       case 'boolean':
         return Boolean;
 
+      case DyFM_BasicProperty_Type.date:
       case 'date':
         return Date;
 
+      case DyFM_BasicProperty_Type.object:
       case 'object':
         return Object;
+
+      case DyFM_BasicProperty_Type.array:
+      case 'array':
+        return Array;
         
       default:
         if (type.includes('[]') || type.includes('array')) {
@@ -1312,7 +1370,7 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
         } else {
           return Object;
         }
-    }
+    } */
   }
 
   /**
@@ -1341,27 +1399,39 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
     // TOD: ezek a kikommentelt "required: true"-k kellenek, csak félő, hogy gondokat okoznak a 
     // jelenlegi rendszerekben, ezért akkor kell majd visszarakni, ha lesz tesztelői ÉS fejlesztői kapacitás rá
     if (!properties.__created) {
-      properties.__created = { key: '__created', type: 'Date'/* , required: true */ };
+      properties.__created = { 
+        key: '__created', type: DyFM_BasicProperty_Type.date/* , required: true */,
+      };
     }
 
     if (!properties.__createdBy) {
-      properties.__createdBy = { key: '__createdBy', type: 'string'/* , required: true */ };
+      properties.__createdBy = { 
+        key: '__createdBy', type: DyFM_BasicProperty_Type.string/* , required: true */,
+      };
     }
 
     if (!properties.__lastModified) {
-      properties.__lastModified = { key: '__lastModified', type: 'Date'/* , required: true */ };
+      properties.__lastModified = { 
+        key: '__lastModified', type: DyFM_BasicProperty_Type.date/* , required: true */,
+      };
     }
 
     if (!properties.__lastModifiedBy) {
-      properties.__lastModifiedBy = { key: '__lastModifiedBy', type: 'string'/* , required: true */ };
+      properties.__lastModifiedBy = { 
+        key: '__lastModifiedBy', type: DyFM_BasicProperty_Type.string/* , required: true */,
+      };
     }
 
     if (!properties._deleted) {
-      properties._deleted = { key: '_deleted', type: 'Date' };
+      properties._deleted = { 
+        key: '_deleted', type: DyFM_BasicProperty_Type.date,
+      };
     }
 
     if (!properties._deletedBy) {
-      properties._deletedBy = { key: '_deletedBy', type: 'string' };
+      properties._deletedBy = { 
+        key: '_deletedBy', type: DyFM_BasicProperty_Type.string,
+      };
     }
 
     return properties;
@@ -1379,14 +1449,15 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
   ): DyFM_DataProperties<T> {
     if (!properties._originalId) {
       properties._originalId = { 
-        key: '_originalId', type: 'string', 
+        key: '_originalId', type: DyFM_BasicProperty_Type.string,
         required: true, index: true, unique: true,
       };
     }
 
     if (!properties._archived) {
       properties._archived = { 
-        key: '_archived', type: 'Date', required: true, 
+        key: '_archived', type: DyFM_BasicProperty_Type.date,
+        required: true, 
       };
     }
 
@@ -1397,15 +1468,15 @@ export class DyNTS_DBService<T extends DyFM_Metadata> {
    * sets depDataKey
    */
   private lookForDependencyDataSettings(): void {
-    const dependencyParams: DyFM_DataProperty_Params<any>[] = 
+    const dependencyParams: DyFM_DataProperty_Params<any, T>[] = 
       Object.values(this.dataParams.properties).filter(
-        (modelParams: DyFM_DataProperty_Params<any>): boolean => 
+        (modelParams: DyFM_DataProperty_Params<any, T>): boolean => 
           Boolean(modelParams.dependencyDataName)
       );
     
     if (dependencyParams) {
       this.depKeys.push(...dependencyParams.map(
-        (dependencyParam: DyFM_DataProperty_Params<any>): string => dependencyParam.key
+        (dependencyParam: DyFM_DataProperty_Params<any, T>): string => dependencyParam.key
       ));
     }
   }