@futdevpro/nts-dynamo 1.10.4 → 1.10.6

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

@@ -2,19 +2,24 @@
 import {
   DyFM_AnyError,
   DyFM_Array,
+  DyFM_BasicProperty_Type,
   DyFM_Data_Params,
   DyFM_DataModel_Params,
   DyFM_DataProperty_Params,
   DyFM_DBFilter,
+  DyFM_DBĐNestedPropertySort,
+  DyFM_DBĐPropertySort,
   DyFM_DBĐSort,
   DyFM_Error,
   DyFM_Error_Settings,
   DyFM_ErrorLevel,
   DyFM_Log,
   DyFM_Metadata,
+  DyFM_NestPropertySearch,
   DyFM_RangeValue,
   DyFM_SearchQuery,
-  DyFM_SearchResult
+  DyFM_SearchResult,
+  DyFM_SpecialSearch
 } from '@futdevpro/fsm-dynamo';
 
 import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
@@ -201,7 +206,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
 
       let dataExists: T = await this.dataDBService.getDataById(id);
 
-      if (this.haveArchiveDataService && !skipArchiveLoad) {
+      if (!dataExists && this.haveArchiveDataService && !skipArchiveLoad) {
         const archiveDataService: DyNTS_ArchiveDataService<T> = this.getArchiveDataService();
         
         dataExists = await archiveDataService.getDataByOriginalId(id, true);
@@ -723,7 +728,24 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
 
       await this.validateForSave(data);
 
-      if (!data._id && (!this.depKey || !data[this.depKey])) {
+      if (!data._id) {
+        if (this.depKey && !data[this.depKey]) {
+          throw new DyFM_Error({ 
+            ...this._getDefaultErrorSettings(
+              'saveData',
+              new Error(
+                `saveData was unsuccessful: dependency data id missing from data ` +
+                `(key: ${this.depKey}, ${this.dataParams.dataName})`
+              )
+            ),
+
+            errorCode: 'NTS-DS0-SD1',
+            additionalContent: {
+              data: data,
+            },
+          });
+        }
+
         // if ID of dependencyID is not present, data not exists, create new data
         data = await this.dataDBService.createData(data, this.issuer);
 
@@ -750,7 +772,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
               )
             ),
 
-            errorCode: 'NTS-DS0-SD1',
+            errorCode: 'NTS-DS0-SD2',
             additionalContent: {
               data: data,
             },
@@ -778,7 +800,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
               )
             ),
             
-            errorCode: 'NTS-DS0-SD2',
+            errorCode: 'NTS-DS0-SD3',
             additionalContent: {
               data: data,
             },
@@ -815,7 +837,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
                   )
                 ),
                 
-                errorCode: 'NTS-DS0-SD3',
+                errorCode: 'NTS-DS0-SD4',
               });
             }
           }
@@ -835,7 +857,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
             )
           ),
           
-          errorCode: 'NTS-DS0-SD4',
+          errorCode: 'NTS-DS0-SD5',
           additionalContent: {
             data: data,
           },
@@ -854,6 +876,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         'NTS-DS0-SD2', 
         'NTS-DS0-SD3', 
         'NTS-DS0-SD4',
+        'NTS-DS0-SD5',
       ].includes(error?.errorCode)) {
         throw error;
 
@@ -1101,7 +1124,10 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         }
       );
     } catch (error) {
-      if ([ 'NTS-DS0-VD1', 'NTS-DS0-VD2' ].includes(error?.errorCode)) {
+      if ([ 
+        'NTS-DS0-VD1', 
+        'NTS-DS0-VD2' 
+      ].includes(error?.errorCode)) {
         throw error;
       } else {
         throw new DyFM_Error({ 
@@ -1165,24 +1191,92 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         dataList = await this.getAll();
       }
 
-      const filterKeys = Object.keys(query.filterBy);
+      const filterKeys: string[] = Object.keys(query.filterBy);
       const filterFunctionsByKey: { [key: string]: (dataProperty) => boolean } = {};
 
+      const addFilterKeys: string[] = [];
+      const removeFilterKeys: string[] = [];
+
       filterKeys.forEach((key: string): void => {
-        filterFunctionsByKey[key] = this.getFilterFunctionForKey(
-          key, query.filterBy[key]
-        );
+        const filterBy = query.filterBy[key];
+
+        if (filterBy.isSpecialNestSearch) {
+          filterBy.nestedPropertySearches.forEach((nestSearch: DyFM_NestPropertySearch<any>): void => {
+            const nestKey = nestSearch.nestKeys.join('.');
+            filterFunctionsByKey[nestKey] = this.getFilterFunctionForKey(
+              nestKey, 
+              nestSearch.search, 
+              nestSearch.valueType
+            );
+            query.filterBy[nestKey] = nestSearch;
+            addFilterKeys.push(nestKey);
+          });
+          removeFilterKeys.push(key);
+        } else {
+          filterFunctionsByKey[key] = this.getFilterFunctionForKey(key, filterBy);
+        }
+      });
+
+      addFilterKeys.forEach((key: string): void => {
+        filterKeys.push(key);
+      });
+      removeFilterKeys.forEach((key: string): void => {
+        filterKeys.splice(filterKeys.indexOf(key), 1);
       });
 
       query.sortBy.forEach((sort: DyFM_DBĐSort): void => {
-        dataList.sort(this.getSortFunctionForKey(sort.key, sort.order));
+        dataList.sort(this.getSortFunctionForKey(sort));
       });
 
-      dataList = dataList.filter(
-        (data: T): boolean => filterKeys.every(
-          (key: string): boolean => filterFunctionsByKey[key](data[key])
-        )
-      );
+      if (filterKeys.some((key: string): boolean => key.includes('.'))) { 
+        const keyResolvers: { [key: string]: (data: T) => any } = {};
+
+        filterKeys.forEach((key: string): void => {
+          if (key.includes('.')) {
+            if (!query.filterBy[key].nestKeys) {
+              throw new DyFM_Error({
+                ...this._getDefaultErrorSettings(
+                  'searchData',
+                  new Error(
+                    `searchData failed, nestKeys missing from nestedPropertySearch! ` +
+                    `(${this.dataParams.dataName})`
+                  )
+                ),
+
+                errorCode: 'NTS-DS0-SD1',
+              });
+            }
+
+            keyResolvers[key] = this.getKeyResolver(query.filterBy[key].nestKeys);
+          } else {
+            keyResolvers[key] = (data: T): any => data[key];
+          }
+        });
+
+        if (filterKeys.some((key: string): boolean => query.filterBy[key].isSpecialNestSearch)) {
+          dataList = dataList.filter(
+            (data: T): boolean => filterKeys.every(
+              (key: string): boolean => query.filterBy[key].isSpecialNestSearch ? 
+                keyResolvers[key](data).some(
+                  (dataProperty: any): boolean => filterFunctionsByKey[key](dataProperty)
+                ) : 
+                filterFunctionsByKey[key](keyResolvers[key](data))
+            )
+          );
+        } else {
+          dataList = dataList.filter(
+            (data: T): boolean => filterKeys.every(
+              (key: string): boolean => filterFunctionsByKey[key](keyResolvers[key](data))
+            )
+          );
+        }
+      } else {
+        dataList = dataList.filter(
+          (data: T): boolean => filterKeys.every(
+            (key: string): boolean => filterFunctionsByKey[key](data[key])
+          )
+        );
+      }
 
       return {
         results: dataList,
@@ -1197,47 +1291,49 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
-  protected getFilterFunctionForKey<T>(
+  protected getFilterFunctionForKey<T, N>(
     key: string, 
-    searchValue: T | T[] | DyFM_RangeValue<T>,
+    searchValue: T | T[] | DyFM_RangeValue<T> | DyFM_SpecialSearch<N>,
+    propertyType?: DyFM_BasicProperty_Type
   ): (dataProperty) => boolean {
-    if (!this.dataParams.properties[key]) {
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          'getFilterFunctionForKey',
-          new Error(
-            `getFilterFunctionForKey failed, key not found in dataParams ` +
-            `(${this.dataParams.dataName})`
-          )
-        ),
+    try {
+      if (searchValue === undefined) {
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'getFilterFunctionForKey',
+            new Error(
+              `getFilterFunctionForKey failed, searchValue is missing for key: "${key}" ` +
+              `(${this.dataParams.dataName})`
+            )
+          ),
 
-        errorCode: 'NTS-DS0-GFF1',
-      });
-    }
+          errorCode: 'NTS-DS0-GFF1',
+        });
+      }
 
-    if (searchValue === undefined) {
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          'getFilterFunctionForKey',
-          new Error(
-            `getFilterFunctionForKey failed, searchValue is missing! ` +
-            `(${this.dataParams.dataName})`
-          )
-        ),
+      if (!key.includes('.')) {
+        if (!this.dataParams.properties[key]) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'getFilterFunctionForKey',
+              new Error(
+                `getFilterFunctionForKey failed, key not found in dataParams: "${key}" ` +
+                `(${this.dataParams.dataName})`
+              )
+            ),
 
-        errorCode: 'NTS-DS0-GFF2',
-      });
-    }
+            errorCode: 'NTS-DS0-GFF2',
+          });
+        }
 
-    
-    switch (this.dataParams.properties[key].type) {
-      case 'String':
-        if (typeof searchValue !== 'string') {
+        propertyType = this.dataParams.properties[key].type;
+      } else {
+        if (!propertyType) {
           throw new DyFM_Error({
             ...this._getDefaultErrorSettings(
               'getFilterFunctionForKey',
               new Error(
-                `getFilterFunctionForKey failed, searchValue is not a string! ` +
+                `getFilterFunctionForKey failed, propertyType is missing for key: "${key}" ` +
                 `(${this.dataParams.dataName})`
               )
             ),
@@ -1246,79 +1342,256 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
           });
         }
 
-        const lowerCaseSearchValue: string = (searchValue as string).toLowerCase();
 
-        return (dataProperty): boolean => 
-          (dataProperty as string).toLowerCase().includes(lowerCaseSearchValue);
+      }
+      
+      switch (propertyType) {
+        case DyFM_BasicProperty_Type.string:
+          if (typeof searchValue !== 'string') {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'getFilterFunctionForKey',
+                new Error(
+                  `getFilterFunctionForKey failed, searchValue is not a string! ` +
+                  `(${this.dataParams.dataName})`
+                )
+              ),
 
-      case 'Date':
-        if ((searchValue as DyFM_RangeValue).isRange) {
-          const rangeAsNumber = new DyFM_RangeValue<number>(
-            +new Date((searchValue as DyFM_RangeValue).from),
-            +new Date((searchValue as DyFM_RangeValue).to)
-          );
+              errorCode: 'NTS-DS0-GFF4',
+            });
+          }
 
-          return (dataProperty): boolean => DyFM_RangeValue.isInRange(
-            +new Date(dataProperty), rangeAsNumber
-          );
-        }
+          if (Array.isArray(searchValue)) {
+            const lowerCaseSearchValueArray: string[] = (searchValue as string[]).filter(
+              (searchString: string): boolean => Boolean(searchString)
+            ).map(
+              (searchString: string): string => searchString.toLowerCase()
+            );
 
-        if (Array.isArray(searchValue)) {
-          const searchValueAsDateArray = (searchValue as Date[]).map(
-            (date: Date): Date => new Date(date)
-          );
+            return (dataProperty: string): boolean => lowerCaseSearchValueArray.some(
+              (searchString: string): boolean => dataProperty?.toLowerCase().includes(searchString)
+            );
+          } else {
+            const lowerCaseSearchValue: string = (searchValue as string)?.toLowerCase();
+
+            if (!lowerCaseSearchValue) {
+              return (dataProperty: string): boolean => !dataProperty;
+            }
+
+            return (dataProperty: string): boolean => 
+              dataProperty?.toLowerCase().includes(lowerCaseSearchValue);
+          }
+
+        case DyFM_BasicProperty_Type.date:
+          if ((searchValue as DyFM_RangeValue).isRange) {
+            if (
+              (searchValue as DyFM_RangeValue).from === undefined ||
+              (searchValue as DyFM_RangeValue).from === null
+            ) {
+              const toAsNumber = +new Date((searchValue as DyFM_RangeValue).to);
+
+              return (dataProperty): boolean => +new Date(dataProperty) <= toAsNumber;
+            } else if (
+              (searchValue as DyFM_RangeValue).to === undefined ||
+              (searchValue as DyFM_RangeValue).to === null
+            ) {
+              const fromAsNumber = +new Date((searchValue as DyFM_RangeValue).from);
+
+              return (dataProperty): boolean => +new Date(dataProperty) >= fromAsNumber;
+            }
+            
+            const rangeAsNumber = new DyFM_RangeValue<number>(
+              +new Date((searchValue as DyFM_RangeValue).from),
+              +new Date((searchValue as DyFM_RangeValue).to)
+            );
+
+            return (dataProperty): boolean => DyFM_RangeValue.isInRange(
+              +new Date(dataProperty), rangeAsNumber
+            );
+          }
 
-          return (dataProperty): boolean => searchValueAsDateArray.includes(new Date(dataProperty));
-        }          
+          if (Array.isArray(searchValue)) {
+            const searchValueAsNumberArray: number[] = (searchValue as Date[]).map(
+              (date: Date): number => +new Date(date)
+            );
+
+            return (dataProperty): boolean => searchValueAsNumberArray.includes(+new Date(dataProperty));
+          }
+
+          const searchValueAsNumber: number = +new Date(searchValue as Date);
+
+          return (dataProperty): boolean => +new Date(dataProperty) === searchValueAsNumber;
+
+        case DyFM_BasicProperty_Type.number:
+          if ((searchValue as DyFM_RangeValue).isRange) {
+            if (
+              (searchValue as DyFM_RangeValue).from === undefined ||
+              (searchValue as DyFM_RangeValue).from === null
+            ) {
+              return (dataProperty): boolean => dataProperty <= (searchValue as DyFM_RangeValue).to;
+            } else if (
+              (searchValue as DyFM_RangeValue).to === undefined ||
+              (searchValue as DyFM_RangeValue).to === null
+            ) {
+              return (dataProperty): boolean => dataProperty >= (searchValue as DyFM_RangeValue).from;
+            }
+
+            return (dataProperty): boolean => DyFM_RangeValue.isInRange(
+              dataProperty, searchValue as DyFM_RangeValue<number>
+            );
+          }
+
+          if (Array.isArray(searchValue)) {
+            return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
+          }
           
-        const searchValueAsDate: Date = new Date(searchValue as Date);
+          return (dataProperty): boolean => dataProperty === searchValue;
 
-        return (dataProperty): boolean => new Date(dataProperty) === searchValueAsDate;
+        case DyFM_BasicProperty_Type.boolean:
+          return (dataProperty): boolean => dataProperty === searchValue;
 
-      case 'Number':
-        if ((searchValue as DyFM_RangeValue).isRange) {
-          return (dataProperty): boolean => DyFM_RangeValue.isInRange(
-            dataProperty, searchValue as DyFM_RangeValue<number>
-          );
-        }
+        case DyFM_BasicProperty_Type.object:
+          if (Array.isArray(searchValue)) {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'getFilterFunctionForKey',
+                new Error(
+                  `getFilterFunctionForKey failed, array search not implemented for this type ` +
+                  `(${this.dataParams.dataName})`
+                )
+              ),
 
-        if (Array.isArray(searchValue)) {
-          return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
-        }
-        
-        return (dataProperty): boolean => dataProperty === searchValue;
+              errorCode: 'NTS-DS0-GFF5',
+            });
+          }
 
-      case 'Boolean':
-        return (dataProperty): boolean => dataProperty === searchValue;
+          return (dataProperty): boolean => {
+            const searchValueKeys: string[] = Object.keys(searchValue as object);
+            const stringifiedSearchValue = {};
 
-      default:
-        if ((searchValue as DyFM_RangeValue).isRange) {
-          throw new DyFM_Error({
-            ...this._getDefaultErrorSettings(
-              'getFilterFunctionForKey',
-              new Error(
-                `getFilterFunctionForKey failed, range search not implemented for this type ` +
-                `(${this.dataParams.dataName})`
-              )
-            ),
+            try {
+              searchValueKeys.forEach(
+                (key: string): void => {
+                  stringifiedSearchValue[key] = JSON.stringify(searchValue[key]);
+                }
+              );
+            } catch (error) {
+              throw new DyFM_Error({
+                ...this._getDefaultErrorSettings(
+                  'getFilterFunctionForKey',
+                  new Error(
+                    `getFilterFunctionForKey failed, object search failed! ` +
+                    `(${this.dataParams.dataName})`
+                  )
+                ),
 
-            errorCode: 'NTS-DS0-GFF3',
-          });
-        }
+                errorCode: 'NTS-DS0-GFF6',
+                additionalContent: {
+                  searchValue: searchValue,
+                },
+              });
+            }
 
-        if (Array.isArray(searchValue)) {
-          return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
+            return searchValueKeys.every(
+              (key: string): boolean => {
+                try {
+                  return stringifiedSearchValue[key] === JSON.stringify(dataProperty[key]);
+                } catch (error) {
+                  console.error(
+                    'object filter returning false, bc of an error',
+                    'searchValue:', searchValue,
+                    'dataProperty:', dataProperty,
+                    'key:', key,
+                    'error:', error
+                  );
+                  return false;
+                }
+              }
+            );
+          }
+
+        default:
+          if ((searchValue as DyFM_RangeValue).isRange) {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'getFilterFunctionForKey',
+                new Error(
+                  `getFilterFunctionForKey failed, range search not implemented for this type ` +
+                  `(${this.dataParams.dataName})`
+                )
+              ),
+
+              errorCode: 'NTS-DS0-GFF7',
+            });
+          }
+
+          if (Array.isArray(searchValue)) {
+            return (dataProperty): boolean => (searchValue as number[]).includes(dataProperty);
+          }
+          
+          return (dataProperty): boolean => dataProperty === searchValue;
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          'getFilterFunctionForKey',
+          error
+        ),
+
+        errorCode: 'NTS-DS0-GFF0',
+        additionalContent: {
+          key: key,
+          searchValue: searchValue,
+          propertyType: propertyType,
+        },
+      });
+    }
+  }
+
+  private getKeyResolver(nestKeys: string[]): (data: T) => any {
+    return (data: T): any => {
+      let value: any = data;
+
+      nestKeys.forEach((nestKey: string): void => {
+        if (!value) {
+          return;
         }
         
-        return (dataProperty): boolean => dataProperty === searchValue;
-    }
+        if (nestKey === '*') {
+          if (Array.isArray(value[nestKey])) {
+            if (Array.isArray(value)) {
+              value = value[nestKey].map((element: any): any => element[nestKey]).flat();
+            } else {
+              value = value[nestKey].map((element: any): any => element[nestKey]);
+            }
+          } else if (value[nestKey] && typeof value[nestKey] === 'object') {
+            value = Object.values(value[nestKey]);
+          } else {
+            value = value[nestKey];
+          }          
+        } else if (Array.isArray(value)) {
+          if (!isNaN(+nestKey)) {
+            value = value[+nestKey];
+          } else {
+            value = value.map((element: any): any => element ? element[nestKey] : element);
+          }
+        } else {
+          value = value[nestKey];
+        }
+      });
+
+      return value;
+    };
   }
 
-  protected getSortFunctionForKey<T>(
-    key: string, 
-    sortDirection: 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending'
-  ): (a: T, b: T) => number {
-    if (!this.dataParams.properties[key]) {
+  protected getSortFunctionForKey<T>(sortSettings: DyFM_DBĐSort): (a: T, b: T) => number {
+    let keyResolver: (data: any) => any;
+    let valueType: DyFM_BasicProperty_Type;
+
+    if (
+      !this.dataParams.properties[(sortSettings as DyFM_DBĐPropertySort).key] &&
+      !(sortSettings as DyFM_DBĐNestedPropertySort).isNestedPropertySort
+    ) {
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'getSortFunctionForKey',
@@ -1331,44 +1604,82 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
         errorCode: 'NTS-DS0-GSF1',
       });
     }
+    
+    if ((sortSettings as DyFM_DBĐNestedPropertySort).isNestedPropertySort) {
+      keyResolver = this.getKeyResolver((sortSettings as DyFM_DBĐNestedPropertySort).nestKeys);
+      valueType = (sortSettings as DyFM_DBĐNestedPropertySort).valueType;
+    } else {
+      keyResolver = (data: T): any => data[(sortSettings as DyFM_DBĐPropertySort).key];
+      valueType = this.dataParams.properties[(sortSettings as DyFM_DBĐPropertySort).key].type;
+    }
+
+    if (!valueType) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          'getSortFunctionForKey',
+          new Error(
+            `getSortFunctionForKey failed, valueType is missing! ` +
+            `(${this.dataParams.dataName})`
+          )
+        ),
+
+        errorCode: 'NTS-DS0-GSF1',
+      });
+    }
 
     const sortValue: 1 | -1 = (
-      sortDirection === 1 || sortDirection === 'asc' || sortDirection === 'ascending'
+      sortSettings.order === 1 || 
+      sortSettings.order === 'asc' || 
+      sortSettings.order === 'ascending'
     ) ? 1 : -1;
 
-    switch (this.dataParams.properties[key].type) {
-      case 'String':
-        return (a: T, b: T): number => (a as string).localeCompare(b as string) * sortValue;
+    switch (valueType) {
+      case DyFM_BasicProperty_Type.string:
+        return (a: T, b: T): number => {
+          a = keyResolver(a);
+          b = keyResolver(b);
+
+          return (a as string).localeCompare(b as string) * sortValue;
+        }
 
-      case 'Date':
+      case DyFM_BasicProperty_Type.date:
         return (a: T, b: T): number => {
-          if (+new Date(a[key]) < +new Date(b[key])) {
+          const aNum = +new Date(keyResolver(a));
+          const bNum = +new Date(keyResolver(b));
+
+          if (aNum < bNum) {
             return -sortValue;
-          } else if (+new Date(a[key]) > +new Date(b[key])) {
+          } else if (aNum > bNum) {
             return sortValue;
           } else {
             return 0;
           }
         };
 
-      case 'Number':
+      case DyFM_BasicProperty_Type.number:
         return (a: T, b: T): number => {
-          if (a[key] < b[key]) {
+          a = keyResolver(a);
+          b = keyResolver(b);
+
+          if (a < b) {
             return -sortValue;
-          } else if (a[key] > b[key]) {
+          } else if (a > b) {
             return sortValue;
           } else {
             return 0;
           }
         };
 
-      case 'Boolean':
+      case DyFM_BasicProperty_Type.boolean:
         return (a: T, b: T): number => {
-          if (a[key] === b[key]) {
+          a = keyResolver(a);
+          b = keyResolver(b);
+
+          if (a === b) {
             return 0;
           }
 
-          if (a[key]) {
+          if (a) {
             return sortValue;
           }
 
@@ -1381,7 +1692,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
             'getSortFunctionForKey',
             new Error(
               `getSortFunctionForKey failed, sorting not implemented for this type ` +
-              `(${this.dataParams.dataName}, ${this.dataParams.properties[key].type})`
+              `(${this.dataParams.dataName}, ${valueType})`
             )
           ),
 
@@ -1390,6 +1701,86 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     }
   }
 
+  /* private getSortFunctionForNestedKeys<T>(
+    sortSettings: DyFM_DBĐNestedPropertySort
+  ): (a: T, b: T) => number {
+    const nestedPropertyResolver: (data) => any = this.getKeyResolver(sortSettings.nestKeys);
+    
+    const sortValue: 1 | -1 = (
+      sortSettings.order === 1 || 
+      sortSettings.order === 'asc' || 
+      sortSettings.order === 'ascending'
+    ) ? 1 : -1;
+
+    switch (sortSettings.valueType) {
+      case DyFM_BasicProperty_Type.string:
+        return (a: T, b: T): number => {
+          a = nestedPropertyResolver(a);
+          b = nestedPropertyResolver(b);
+
+          return (a as string).localeCompare(b as string) * sortValue
+        };
+
+      case DyFM_BasicProperty_Type.date:
+        return (a: T, b: T): number => {
+          a = nestedPropertyResolver(a);
+          b = nestedPropertyResolver(b);
+
+          if (+new Date(a) < +new Date(b)) {
+            return -sortValue;
+          } else if (+new Date(a) > +new Date(b)) {
+            return sortValue;
+          } else {
+            return 0;
+          }
+        };
+
+      case DyFM_BasicProperty_Type.number:
+        return (a: T, b: T): number => {
+          a = nestedPropertyResolver(a);
+          b = nestedPropertyResolver(b);
+
+          if (a < b) {
+            return -sortValue;
+          } else if (a > b) {
+            return sortValue;
+          } else {
+            return 0;
+          }
+        };
+
+      case DyFM_BasicProperty_Type.boolean:
+        return (a: T, b: T): number => {
+          a = nestedPropertyResolver(a);
+          b = nestedPropertyResolver(b);
+
+          if (a === b) {
+            return 0;
+          }
+
+          if (a) {
+            return sortValue;
+          }
+
+          return -sortValue;
+        };
+
+      default:
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'getSortFunctionForKey',
+            new Error(
+              `getSortFunctionForKey failed, sorting not implemented for this type ` +
+              `(${this.dataParams.dataName}, ${this.dataParams.properties[key].type})`
+            )
+          ),
+
+          errorCode: 'NTS-DS0-GSF2',
+        });
+    }
+  } */
+    
+
   /**
    * setting up dependency dataHook by DynamoBEDataModelParams
    */
@@ -1452,6 +1843,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     return {
       status: (error as DyFM_Error)?.___status ?? 500,
       message: (error as Error)?.message ??
+        (error as DyFM_Error)?._message ??
         `${fnName} was UNSUCCESSFUL (NTS; ${this.dataParams.dataName})`,
       addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
       userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
@@ -1468,6 +1860,7 @@ export class DyNTS_DataService<T extends DyFM_Metadata> {
     return {
       status: (error as DyFM_Error)?.___status ?? 500,
       message: (error as Error)?.message ??
+        (error as DyFM_Error)?._message ??
         `${fnName} was UNSUCCESSFUL (${DyNTS_global_settings.systemShortCodeName})`,
       addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
       userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,