@futdevpro/nts-dynamo 1.10.5 → 1.10.7

package/build/_services/base/data.service.js

@@ -148,7 +148,7 @@ class DyNTS_DataService {
                 });
             }
             let dataExists = await this.dataDBService.getDataById(id);
-            if (this.haveArchiveDataService && !skipArchiveLoad) {
+            if (!dataExists && this.haveArchiveDataService && !skipArchiveLoad) {
                 const archiveDataService = this.getArchiveDataService();
                 dataExists = await archiveDataService.getDataByOriginalId(id, true);
             }
@@ -558,7 +558,17 @@ class DyNTS_DataService {
         try {
             data = this.ensureData(data);
             await this.validateForSave(data);
-            if (!data._id && (!this.depKey || !data[this.depKey])) {
+            if (!data._id) {
+                if (this.depKey && !data[this.depKey]) {
+                    throw new fsm_dynamo_1.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);
                 if (!dontSetToService) {
@@ -574,7 +584,7 @@ class DyNTS_DataService {
                     throw new fsm_dynamo_1.DyFM_Error({
                         ...this._getDefaultErrorSettings('saveData', new Error(`saveData was unsuccessful: provided ID not exists ` +
                             `(id: "${data._id}", ${this.dataParams.dataName})`)),
-                        errorCode: 'NTS-DS0-SD1',
+                        errorCode: 'NTS-DS0-SD2',
                         additionalContent: {
                             data: data,
                         },
@@ -592,7 +602,7 @@ class DyNTS_DataService {
                     throw new fsm_dynamo_1.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-SD2',
+                        errorCode: 'NTS-DS0-SD3',
                         additionalContent: {
                             data: data,
                         },
@@ -618,7 +628,7 @@ class DyNTS_DataService {
                                 ...this._getDefaultErrorSettings('saveData', new Error(`saveData was unsuccessful: dependency data not exists ` +
                                     `(key: ${this.depKey}, id: "${data[this.depKey]}", ` +
                                     `${this.dataParams.dataName})`)),
-                                errorCode: 'NTS-DS0-SD3',
+                                errorCode: 'NTS-DS0-SD4',
                             });
                         }
                     }
@@ -630,7 +640,7 @@ class DyNTS_DataService {
                 throw new fsm_dynamo_1.DyFM_Error({
                     ...this._getDefaultErrorSettings('saveData', new Error(`saveData was unsuccessful: data creation failed ` +
                         `(${this.dataParams.dataName})`)),
-                    errorCode: 'NTS-DS0-SD4',
+                    errorCode: 'NTS-DS0-SD5',
                     additionalContent: {
                         data: data,
                     },
@@ -647,6 +657,7 @@ class DyNTS_DataService {
                 'NTS-DS0-SD2',
                 'NTS-DS0-SD3',
                 'NTS-DS0-SD4',
+                'NTS-DS0-SD5',
             ].includes(error?.errorCode)) {
                 throw error;
             }
@@ -827,7 +838,10 @@ class DyNTS_DataService {
             });
         }
         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 {
@@ -877,13 +891,61 @@ class DyNTS_DataService {
             }
             const filterKeys = Object.keys(query.filterBy);
             const filterFunctionsByKey = {};
+            const addFilterKeys = [];
+            const removeFilterKeys = [];
             filterKeys.forEach((key) => {
-                filterFunctionsByKey[key] = this.getFilterFunctionForKey(key, query.filterBy[key]);
+                const filterBy = query.filterBy[key];
+                if (filterBy.isSpecialNestSearch) {
+                    filterBy.nestedPropertySearches.forEach((nestSearch) => {
+                        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) => {
+                filterKeys.push(key);
+            });
+            removeFilterKeys.forEach((key) => {
+                filterKeys.splice(filterKeys.indexOf(key), 1);
             });
             query.sortBy.forEach((sort) => {
-                dataList.sort(this.getSortFunctionForKey(sort.key, sort.order));
+                dataList.sort(this.getSortFunctionForKey(sort));
             });
-            dataList = dataList.filter((data) => filterKeys.every((key) => filterFunctionsByKey[key](data[key])));
+            if (filterKeys.some((key) => key.includes('.'))) {
+                const keyResolvers = {};
+                filterKeys.forEach((key) => {
+                    if (key.includes('.')) {
+                        if (!query.filterBy[key].nestKeys) {
+                            throw new fsm_dynamo_1.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) => data[key];
+                    }
+                });
+                if (filterKeys.some((key) => query.filterBy[key].isSpecialNestSearch)) {
+                    dataList = dataList.filter((data) => filterKeys.every((key) => query.filterBy[key].isSpecialNestSearch ?
+                        keyResolvers[key](data).some((dataProperty) => filterFunctionsByKey[key](dataProperty)) :
+                        filterFunctionsByKey[key](keyResolvers[key](data))));
+                }
+                else {
+                    dataList = dataList.filter((data) => filterKeys.every((key) => filterFunctionsByKey[key](keyResolvers[key](data))));
+                }
+            }
+            else {
+                dataList = dataList.filter((data) => filterKeys.every((key) => filterFunctionsByKey[key](data[key])));
+            }
             return {
                 results: dataList,
                 totalItems: dataList.length,
@@ -896,109 +958,265 @@ class DyNTS_DataService {
             });
         }
     }
-    getFilterFunctionForKey(key, searchValue) {
-        if (!this.dataParams.properties[key]) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, key not found in dataParams ` +
-                    `(${this.dataParams.dataName})`)),
-                errorCode: 'NTS-DS0-GFF1',
-            });
-        }
-        if (searchValue === undefined) {
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, searchValue is missing! ` +
-                    `(${this.dataParams.dataName})`)),
-                errorCode: 'NTS-DS0-GFF2',
-            });
-        }
-        switch (this.dataParams.properties[key].type) {
-            case 'String':
-                if (typeof searchValue !== 'string') {
+    getFilterFunctionForKey(key, searchValue, propertyType) {
+        try {
+            if (searchValue === undefined) {
+                throw new fsm_dynamo_1.DyFM_Error({
+                    ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, searchValue is missing for key: "${key}" ` +
+                        `(${this.dataParams.dataName})`)),
+                    errorCode: 'NTS-DS0-GFF1',
+                });
+            }
+            if (!key.includes('.')) {
+                if (!this.dataParams.properties[key]) {
                     throw new fsm_dynamo_1.DyFM_Error({
-                        ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, searchValue is not a string! ` +
+                        ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, key not found in dataParams: "${key}" ` +
                             `(${this.dataParams.dataName})`)),
-                        errorCode: 'NTS-DS0-GFF3',
+                        errorCode: 'NTS-DS0-GFF2',
                     });
                 }
-                const lowerCaseSearchValue = searchValue.toLowerCase();
-                return (dataProperty) => dataProperty.toLowerCase().includes(lowerCaseSearchValue);
-            case 'Date':
-                if (searchValue.isRange) {
-                    const rangeAsNumber = new fsm_dynamo_1.DyFM_RangeValue(+new Date(searchValue.from), +new Date(searchValue.to));
-                    return (dataProperty) => fsm_dynamo_1.DyFM_RangeValue.isInRange(+new Date(dataProperty), rangeAsNumber);
-                }
-                if (Array.isArray(searchValue)) {
-                    const searchValueAsDateArray = searchValue.map((date) => new Date(date));
-                    return (dataProperty) => searchValueAsDateArray.includes(new Date(dataProperty));
-                }
-                const searchValueAsDate = new Date(searchValue);
-                return (dataProperty) => new Date(dataProperty) === searchValueAsDate;
-            case 'Number':
-                if (searchValue.isRange) {
-                    return (dataProperty) => fsm_dynamo_1.DyFM_RangeValue.isInRange(dataProperty, searchValue);
-                }
-                if (Array.isArray(searchValue)) {
-                    return (dataProperty) => searchValue.includes(dataProperty);
-                }
-                return (dataProperty) => dataProperty === searchValue;
-            case 'Boolean':
-                return (dataProperty) => dataProperty === searchValue;
-            default:
-                if (searchValue.isRange) {
+                propertyType = this.dataParams.properties[key].type;
+            }
+            else {
+                if (!propertyType) {
                     throw new fsm_dynamo_1.DyFM_Error({
-                        ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, range search not implemented for this type ` +
+                        ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, propertyType is missing for key: "${key}" ` +
                             `(${this.dataParams.dataName})`)),
                         errorCode: 'NTS-DS0-GFF3',
                     });
                 }
-                if (Array.isArray(searchValue)) {
-                    return (dataProperty) => searchValue.includes(dataProperty);
-                }
-                return (dataProperty) => dataProperty === searchValue;
+            }
+            switch (propertyType) {
+                case fsm_dynamo_1.DyFM_BasicProperty_Type.string:
+                    if (typeof searchValue !== 'string') {
+                        throw new fsm_dynamo_1.DyFM_Error({
+                            ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, searchValue is not a string! ` +
+                                `(${this.dataParams.dataName})`)),
+                            errorCode: 'NTS-DS0-GFF4',
+                        });
+                    }
+                    if (Array.isArray(searchValue)) {
+                        const lowerCaseSearchValueArray = searchValue.filter((searchString) => Boolean(searchString)).map((searchString) => searchString.toLowerCase());
+                        return (dataProperty) => lowerCaseSearchValueArray.some((searchString) => dataProperty?.toLowerCase().includes(searchString));
+                    }
+                    else {
+                        const lowerCaseSearchValue = searchValue?.toLowerCase();
+                        if (!lowerCaseSearchValue) {
+                            return (dataProperty) => !dataProperty;
+                        }
+                        return (dataProperty) => dataProperty?.toLowerCase().includes(lowerCaseSearchValue);
+                    }
+                case fsm_dynamo_1.DyFM_BasicProperty_Type.date:
+                    if (searchValue.isRange) {
+                        if (searchValue.from === undefined ||
+                            searchValue.from === null) {
+                            const toAsNumber = +new Date(searchValue.to);
+                            return (dataProperty) => +new Date(dataProperty) <= toAsNumber;
+                        }
+                        else if (searchValue.to === undefined ||
+                            searchValue.to === null) {
+                            const fromAsNumber = +new Date(searchValue.from);
+                            return (dataProperty) => +new Date(dataProperty) >= fromAsNumber;
+                        }
+                        const rangeAsNumber = new fsm_dynamo_1.DyFM_RangeValue(+new Date(searchValue.from), +new Date(searchValue.to));
+                        return (dataProperty) => fsm_dynamo_1.DyFM_RangeValue.isInRange(+new Date(dataProperty), rangeAsNumber);
+                    }
+                    if (Array.isArray(searchValue)) {
+                        const searchValueAsNumberArray = searchValue.map((date) => +new Date(date));
+                        return (dataProperty) => searchValueAsNumberArray.includes(+new Date(dataProperty));
+                    }
+                    const searchValueAsNumber = +new Date(searchValue);
+                    return (dataProperty) => +new Date(dataProperty) === searchValueAsNumber;
+                case fsm_dynamo_1.DyFM_BasicProperty_Type.number:
+                    if (searchValue.isRange) {
+                        if (searchValue.from === undefined ||
+                            searchValue.from === null) {
+                            return (dataProperty) => dataProperty <= searchValue.to;
+                        }
+                        else if (searchValue.to === undefined ||
+                            searchValue.to === null) {
+                            return (dataProperty) => dataProperty >= searchValue.from;
+                        }
+                        return (dataProperty) => fsm_dynamo_1.DyFM_RangeValue.isInRange(dataProperty, searchValue);
+                    }
+                    if (Array.isArray(searchValue)) {
+                        return (dataProperty) => searchValue.includes(dataProperty);
+                    }
+                    return (dataProperty) => dataProperty === searchValue;
+                case fsm_dynamo_1.DyFM_BasicProperty_Type.boolean:
+                    return (dataProperty) => dataProperty === searchValue;
+                case fsm_dynamo_1.DyFM_BasicProperty_Type.object:
+                    if (Array.isArray(searchValue)) {
+                        throw new fsm_dynamo_1.DyFM_Error({
+                            ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, array search not implemented for this type ` +
+                                `(${this.dataParams.dataName})`)),
+                            errorCode: 'NTS-DS0-GFF5',
+                        });
+                    }
+                    return (dataProperty) => {
+                        const searchValueKeys = Object.keys(searchValue);
+                        const stringifiedSearchValue = {};
+                        try {
+                            searchValueKeys.forEach((key) => {
+                                stringifiedSearchValue[key] = JSON.stringify(searchValue[key]);
+                            });
+                        }
+                        catch (error) {
+                            throw new fsm_dynamo_1.DyFM_Error({
+                                ...this._getDefaultErrorSettings('getFilterFunctionForKey', new Error(`getFilterFunctionForKey failed, object search failed! ` +
+                                    `(${this.dataParams.dataName})`)),
+                                errorCode: 'NTS-DS0-GFF6',
+                                additionalContent: {
+                                    searchValue: searchValue,
+                                },
+                            });
+                        }
+                        return searchValueKeys.every((key) => {
+                            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.isRange) {
+                        throw new fsm_dynamo_1.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) => searchValue.includes(dataProperty);
+                    }
+                    return (dataProperty) => dataProperty === searchValue;
+            }
+        }
+        catch (error) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this._getDefaultErrorSettings('getFilterFunctionForKey', error),
+                errorCode: 'NTS-DS0-GFF0',
+                additionalContent: {
+                    key: key,
+                    searchValue: searchValue,
+                    propertyType: propertyType,
+                },
+            });
         }
     }
-    getSortFunctionForKey(key, sortDirection) {
-        if (!this.dataParams.properties[key]) {
+    getKeyResolver(nestKeys) {
+        return (data) => {
+            let value = data;
+            nestKeys.forEach((nestKey) => {
+                if (!value) {
+                    return;
+                }
+                if (nestKey === '*') {
+                    if (Array.isArray(value[nestKey])) {
+                        if (Array.isArray(value)) {
+                            value = value[nestKey].map((element) => element[nestKey]).flat();
+                        }
+                        else {
+                            value = value[nestKey].map((element) => 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) => element ? element[nestKey] : element);
+                    }
+                }
+                else {
+                    value = value[nestKey];
+                }
+            });
+            return value;
+        };
+    }
+    getSortFunctionForKey(sortSettings) {
+        let keyResolver;
+        let valueType;
+        if (!this.dataParams.properties[sortSettings.key] &&
+            !sortSettings.isNestedPropertySort) {
             throw new fsm_dynamo_1.DyFM_Error({
                 ...this._getDefaultErrorSettings('getSortFunctionForKey', new Error(`getSortFunctionForKey failed, key not found in dataParams ` +
                     `(${this.dataParams.dataName})`)),
                 errorCode: 'NTS-DS0-GSF1',
             });
         }
-        const sortValue = (sortDirection === 1 || sortDirection === 'asc' || sortDirection === 'ascending') ? 1 : -1;
-        switch (this.dataParams.properties[key].type) {
-            case 'String':
-                return (a, b) => a.localeCompare(b) * sortValue;
-            case 'Date':
+        if (sortSettings.isNestedPropertySort) {
+            keyResolver = this.getKeyResolver(sortSettings.nestKeys);
+            valueType = sortSettings.valueType;
+        }
+        else {
+            keyResolver = (data) => data[sortSettings.key];
+            valueType = this.dataParams.properties[sortSettings.key].type;
+        }
+        if (!valueType) {
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this._getDefaultErrorSettings('getSortFunctionForKey', new Error(`getSortFunctionForKey failed, valueType is missing! ` +
+                    `(${this.dataParams.dataName})`)),
+                errorCode: 'NTS-DS0-GSF1',
+            });
+        }
+        const sortValue = (sortSettings.order === 1 ||
+            sortSettings.order === 'asc' ||
+            sortSettings.order === 'ascending') ? 1 : -1;
+        switch (valueType) {
+            case fsm_dynamo_1.DyFM_BasicProperty_Type.string:
+                return (a, b) => {
+                    a = keyResolver(a);
+                    b = keyResolver(b);
+                    return a.localeCompare(b) * sortValue;
+                };
+            case fsm_dynamo_1.DyFM_BasicProperty_Type.date:
                 return (a, b) => {
-                    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 fsm_dynamo_1.DyFM_BasicProperty_Type.number:
                 return (a, b) => {
-                    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 fsm_dynamo_1.DyFM_BasicProperty_Type.boolean:
                 return (a, b) => {
-                    if (a[key] === b[key]) {
+                    a = keyResolver(a);
+                    b = keyResolver(b);
+                    if (a === b) {
                         return 0;
                     }
-                    if (a[key]) {
+                    if (a) {
                         return sortValue;
                     }
                     return -sortValue;
@@ -1006,11 +1224,89 @@ class DyNTS_DataService {
             default:
                 throw new fsm_dynamo_1.DyFM_Error({
                     ...this._getDefaultErrorSettings('getSortFunctionForKey', new Error(`getSortFunctionForKey failed, sorting not implemented for this type ` +
-                        `(${this.dataParams.dataName}, ${this.dataParams.properties[key].type})`)),
+                        `(${this.dataParams.dataName}, ${valueType})`)),
                     errorCode: 'NTS-DS0-GSF2',
                 });
         }
     }
+    /* 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
      */
@@ -1054,6 +1350,7 @@ class DyNTS_DataService {
         return {
             status: error?.___status ?? 500,
             message: error?.message ??
+                error?._message ??
                 `${fnName} was UNSUCCESSFUL (NTS; ${this.dataParams.dataName})`,
             addECToUserMsg: !error?.__userMessage,
             userMessage: error?.__userMessage ?? this.defaultErrorUserMsg,
@@ -1066,6 +1363,7 @@ class DyNTS_DataService {
         return {
             status: error?.___status ?? 500,
             message: error?.message ??
+                error?._message ??
                 `${fnName} was UNSUCCESSFUL (${global_settings_const_1.DyNTS_global_settings.systemShortCodeName})`,
             addECToUserMsg: !error?.__userMessage,
             userMessage: error?.__userMessage ?? this.defaultErrorUserMsg,