@futdevpro/nts-dynamo 1.11.36 → 1.11.38

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
      */
@@ -291,6 +291,12 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     dependencyIds?: string | { [key: string]: string }
   ): { [key: string]: string } {
     if (!this.depSettings.length) {
+      DyFM_Log.warn(
+        `❌ getDataByDependencyId failed, dependencyKey is missing from service! ` +
+        `(${this.dataParams.dataName})` +
+        `\n  📍 ${this.dataParams.stackLocation}`
+      );
+
       throw new DyFM_Error({ 
         ...this._getDefaultErrorSettings(
           'getDataByDependencyId',
@@ -1174,87 +1180,276 @@ 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 (
+          !(date instanceof Date) ||
+          date.toString() === 'Invalid Date' ||
+          (propertyParams.required && 
+            (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-VP6`,
+            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
+        );
+      }
+    }
+  }
+
   async searchData(query?: DyFM_SearchQuery<T>, dataList?: T[]): Promise<DyFM_SearchResult<T>> {
     try {
       const searchResult = await this.sortAndFilterDataList(query, dataList);
@@ -1900,9 +2095,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,27 @@ 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;
@@ -1397,15 +1455,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
       ));
     }
   }

package/src/_services/route/routing-module.service.ts

@@ -93,9 +93,9 @@ export class DyNTS_RoutingModule {
       /* this.serviceName = set.route.replace('/', '') + 'RoutingModule'; */
       this.route = DyNTS_global_settings.baseUrl + set.route;
       this.controllers = set.controllers ?? [];
+      this.stackLocation = DyFM_getConstructionStackLocation();
       this.setupRoutes();
       this.mountRoutes(set.securityOverride);
-      this.stackLocation = DyFM_getConstructionStackLocation();
 
       if (this.logSetup) console.log(
         `routing module setup done: ${this.route} security: ${this.security}\n`
@@ -125,6 +125,7 @@ export class DyNTS_RoutingModule {
 
         message: `Routing module setup failed (${this.route}).`,
         errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-RMS-000`,
+        __localStack: this.stackLocation,
         additionalContent: set,
       });
     }

package/src/_services/server/app.server.ts

@@ -336,14 +336,15 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
       if (error instanceof DyFM_Error) {
         if (error.additionalContent?.constructErrors?.length) {
           error.additionalContent.constructErrors.forEach((errorItem: DyFM_Error): void => {
-            if (errorItem instanceof DyFM_Error) {
+            DyFM_Error.logSimple('(constructor asyncConstruct.catch) error:', errorItem);
+            /* if (errorItem instanceof DyFM_Error) {
               errorItem.logSimple(`(constructor asyncConstruct.catch) error:\n`);
             } else {
               DyFM_Log.H_warn(
                 '(constructor asyncConstruct.catch) additional error content:\n', 
                 errorItem
               );
-            }
+            } */
           });
         } else {
           DyFM_Log.H_warn(
@@ -353,7 +354,8 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
         }
       }
 
-      if (
+      DyFM_Error.logSimple('(constructor asyncConstruct.catch) error:', error);
+      /* if (
         !DyNTS_global_settings.log_settings.highDetailedLogs &&
         (error instanceof DyFM_Error)
       ) {
@@ -367,7 +369,7 @@ export abstract class DyNTS_App extends DyNTS_SingletonService {
           `Application: "${this.params?.name}" start failed. (constructor asyncConstruct.catch)`,
           `\n    ERROR:`, error
         );
-      }
+      } */
 
       const message: string = 
         (error as DyFM_Error)?.additionalContent?.constructErrors?.flatMap(