@futdevpro/nts-dynamo 1.5.50 → 1.5.52

package/src/_services/dynamo-nts-db.service.ts

@@ -11,6 +11,8 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
 
   private depDataName: string;
 
+  defaultErrorUserMsg = 'We encountered an unhandled DB Error, please contact the responsible development team.'
+
   /**
    * @param dataName name the model
    * @param typeSample sample data for scheme creation (dont include Dynamo_Metadata!)
@@ -35,18 +37,16 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
     data.__lastModifiedBy = creator;
 
     const dataModel = new this.dataModel(data);
-    let newData: T;
-
-    await dataModel.save().then(res => {
+    let newData: T = await dataModel.save().then(res => {
       if (res) {
-        newData = res.toObject() as T;
+        return res.toObject() as T;
       } else {
         throw new Dynamo_Error({ 
           status: 204, 
           errorCode: 'NTS-DBS-CD1',
           addECToUserMsg: true,
           message: `save ${this.dataParams.dbName} result not found! (NTS DB)`,
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+          userMessage: this.defaultErrorUserMsg
         });
       }
     }).catch(error => {
@@ -55,7 +55,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-CD0',
         addECToUserMsg: true,
         message: `Create new ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
@@ -79,18 +79,16 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
     data.__lastModifiedBy = modifier;
 
     const dataModel = new this.dataModel(data);
-    let newData: T;
-
-    await this.dataModel.findByIdAndUpdate(data._id, dataModel).then(res => {
+    let newData: T = await this.dataModel.findByIdAndUpdate(data._id, dataModel).then(res => {
       if (res) {
-        newData = res.toObject() as T;
+        return res.toObject() as T;
       } else {
         throw new Dynamo_Error({ 
           status: 204, 
           errorCode: 'NTS-DBS-FU1',
           addECToUserMsg: true,
           message: `update ${this.dataParams.dbName} result not found! (NTS DB)`,
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+          userMessage: this.defaultErrorUserMsg
         });
       }
     }).catch(error => {
@@ -99,11 +97,15 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-FU0',
         addECToUserMsg: true,
         message: `modify ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
 
+    if (typeof newData._id === 'object') {
+      newData._id = `${newData._id}`;
+    }
+    data._id = newData._id;
     data.__v = newData.__v;
 
     return data;
@@ -115,13 +117,11 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @returns data
    */
   async getDataById(id: string): Promise<T> {
-    let data: T;
-
-    await this.dataModel.findById(id).then(res => {
+    let data: T = await this.dataModel.findById(id).then(res => {
       if (res) {
-        data = res.toObject() as T;
+        return res.toObject() as T;
       } else {
-        data = null;
+        return null;
       }
     }).catch(error => {
       throw new Dynamo_Error({ 
@@ -129,7 +129,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-GI0',
         addECToUserMsg: true,
         message: `get ${this.dataParams.dbName} by ID was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
@@ -147,37 +147,38 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @returns data
    */
   async getDataByDependencyId(dependencyId: string): Promise<T> {
-    if (this.depDataName) {
-      let data: T;
-      await this.dataModel.findOne({ [this.depDataName]: dependencyId }).then(res => {
-        if (res) {
-          data = res.toObject() as T;
-        } else {
-          data = null;
-        }
-      }).catch(error => {
-        throw new Dynamo_Error({ 
-          status: 417, 
-          errorCode: 'NTS-DBS-GD1',
-          addECToUserMsg: true,
-          message: `get ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
-          error 
-        });
-      });
-      if (data && typeof data._id === 'object') {
-        data._id = `${data._id}`;
-      }
-      return data;
-    } else {
+    if (!this.depDataName) {
       throw new Dynamo_Error({ 
         status: 501, 
         errorCode: 'NTS-DBS-GD0',
         addECToUserMsg: true,
         message: `dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`,
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+        userMessage: this.defaultErrorUserMsg
+      });
+    }
+
+    let data: T = await this.dataModel.findOne({ [this.depDataName]: dependencyId }).then(res => {
+      if (res) {
+        return res.toObject() as T;
+      } else {
+        return null;
+      }
+    }).catch(error => {
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-DBS-GD1',
+        addECToUserMsg: true,
+        message: `get ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
+        userMessage: this.defaultErrorUserMsg, 
+        error 
       });
+    });
+
+    if (data && typeof data._id === 'object') {
+      data._id = `${data._id}`;
     }
+
+    return data;
   }
 
   /**
@@ -186,37 +187,38 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @returns dataList
    */
   async getDataListByDependencyId(dependencyId: string): Promise<T[]> {
-    if (this.depDataName) {
-      let dataList = [];
-      await this.dataModel.find({ [this.depDataName]: dependencyId }).then(res => {
-        if (res) {
-          dataList = res;
-        }
-      }).catch(error => {
-        throw new Dynamo_Error({ 
-          status: 417, 
-          errorCode: 'NTS-DBS-GLD1',
-          addECToUserMsg: true,
-          message: `get ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
-          error 
-        });
-      });
-      if (0 < dataList.length && typeof dataList[0]._id === 'object') {
-        dataList.forEach((data: T) => {
-          data._id = `˙${data._id}`;
-        });
-      }
-      return dataList;
-    } else {
+    if (!this.depDataName) {
       throw new Dynamo_Error({ 
         status: 501, 
         errorCode: 'NTS-DBS-GLD0',
         addECToUserMsg: true,
         message: `dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`,
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+        userMessage: this.defaultErrorUserMsg
       });
     }
+
+    let dataList: T[] = await this.dataModel.find({ [this.depDataName]: dependencyId })
+    .then(res => res ?? [])
+    .catch(error => {
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-DBS-GLD1',
+        addECToUserMsg: true,
+        message: `get ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
+        userMessage: this.defaultErrorUserMsg, 
+        error 
+      });
+    });
+
+    if (0 < dataList.length) {
+      dataList.forEach((data: T) => {
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
+      });
+    }
+
+    return dataList;
   }
 
   /**
@@ -225,32 +227,38 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @returns dataList
    */
   async getDataListByDependencyIds(ids: string[]): Promise<T[]> {
-    if (this.depDataName) {
-      let dataList = [];
-      await this.dataModel.find({ [this.depDataName]: { $in: ids }}).then(res => {
-        if (res) {
-          dataList = res;
-        }
-      }).catch(error => {
-        throw new Dynamo_Error({ 
-          status: 417, 
-          errorCode: 'NTS-DBS-GLDS1',
-          addECToUserMsg: true,
-          message: `get ${this.dataParams.dbName}s by ${this.depDataName}s was unsuccessful (NTS DB)`, 
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
-          error 
-        });
-      });
-      return dataList;
-    } else {
+    if (!this.depDataName) {
       throw new Dynamo_Error({ 
         status: 501, 
         errorCode: 'NTS-DBS-GLDS0',
         addECToUserMsg: true,
         message: `dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`,
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+        userMessage: this.defaultErrorUserMsg
       });
     }
+
+    let dataList: T[] = await this.dataModel.find({ [this.depDataName]: { $in: ids }})
+    .then(res => res ?? [])
+    .catch(error => {
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-DBS-GLDS1',
+        addECToUserMsg: true,
+        message: `get ${this.dataParams.dbName}s by ${this.depDataName}s was unsuccessful (NTS DB)`, 
+        userMessage: this.defaultErrorUserMsg, 
+        error 
+      });
+    });
+
+    if (0 < dataList.length) {
+      dataList.forEach((data: T) => {
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
+      });
+    }
+
+    return dataList;
   }
 
   /**
@@ -263,34 +271,43 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
   async searchData(searchBy: object, narrowByDependencyIds?: string[]): Promise<T[]> {
     const filter = {};
 
-    if (narrowByDependencyIds.length > 0) {
-      if (this.depDataName) {
-        filter[this.depDataName] = { $in: narrowByDependencyIds };
-      } else {
+    if (0 < narrowByDependencyIds.length) {
+      if (!this.depDataName) {
         throw new Dynamo_Error({ 
           status: 501, 
           errorCode: 'NTS-DBS-SD0',
           addECToUserMsg: true,
           message: `dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`,
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+          userMessage: this.defaultErrorUserMsg
         });
       }
+      
+      filter[this.depDataName] = { $in: narrowByDependencyIds };      
     }
 
     await this.dataParams.modelParams.forEach((modelParam: DynamoNTS_DataPropertyParams) => {
-      if ((searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) || searchBy[modelParam.key + 'Range']) {
+      if (
+        (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) || 
+        searchBy[modelParam.key + 'Range']
+      ) {
         if (modelParam.key.includes('Range') || modelParam.type.includes('[]')) {
           // inverz search filter (for Range and Array functions)
           if (modelParam.key.includes('Range')) {
             const searchParamKeyWithoutRange = modelParam.key.split('Range')[0];
-            if (searchBy[searchParamKeyWithoutRange] !== null && searchBy[searchParamKeyWithoutRange] !== undefined) {
+            if (
+              searchBy[searchParamKeyWithoutRange] !== null && 
+              searchBy[searchParamKeyWithoutRange] !== undefined
+            ) {
               filter[modelParam.key] = {
                 from: { $lte: searchBy[searchParamKeyWithoutRange] },
                 to: { $gte: searchBy[searchParamKeyWithoutRange] }
               };
             }
           } else {
-            if (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) {
+            if (
+              searchBy[modelParam.key] !== null && 
+              searchBy[modelParam.key] !== undefined
+            ) {
               filter[modelParam.key] = { $in: searchBy[modelParam.key] };
             }
           }
@@ -315,77 +332,44 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       }
     });
 
-    let dataList = [];
-    await this.dataModel.find(filter).then(res => {
-      if (res) {
-        dataList = res;
-      }
-    }).catch(error => {
+    let dataList: T[] = await this.dataModel.find(filter)
+    .then(res => res ?? [])
+    .catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-SD1',
         addECToUserMsg: true,
         message: `search ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
 
-    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+    if (0 < dataList.length) {
       dataList.forEach((data: T) => {
-        data._id = `˙${data._id}`;
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
       });
     }
 
-    return dataList as T[];
+    return dataList;
   }
 
-  /**
-   * find data by any of its parameters, throws error if not found
-   * @param data 
-   * (always use unique parameters for find!)
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is greater than OR less than:
-   * @example { points: { $gte: 2, $lte: 14 } }
-   * @returns data
-   */
-  /* async findData(data: T): Promise<T> {
-    await this.dataModel.findOne(data).then(res => {
-      if (res) {
-        data = res.toObject() as T;
-      } else {
-        data = null;
-      }
-    }).catch(error => {
-      throw new Dynamo_Error({ status: 417, message: `find ${this.dataParams.dbName} was unsuccessful (NTS DB)`, error });
-    });
-    if (data && typeof data._id === 'object') {
-      data._id = `${data._id}`;
-    }
-    return data;
-  } */
-
   /**
    * returns all data from database, throws error if not found
    * @returns dataList
    */
   async getAll(): Promise<T[]> {
-    let dataList = [];
-
-    await this.dataModel.find({}).then(res => {
-      if (res) {
-        dataList = res;
-      }
-    }).catch(error => {
+    let dataList: T[] = await this.dataModel.find({})
+    .then(res => res ?? [])
+    .catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-GA0',
         addECToUserMsg: true,
         message: `get all ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
@@ -410,7 +394,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-DD0',
         addECToUserMsg: true,
         message: `delete ${this.dataParams.dbName} was unsuccessful (NTS DB)`,
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`,  
+        userMessage: this.defaultErrorUserMsg,  
         error 
       });
     });
@@ -421,59 +405,64 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @param dependencyId id
    */
   async deleteDataByDependencyId(dependencyId: string): Promise<void> {
-    if (this.depDataName) {
-      await this.dataModel.deleteMany({ [this.depDataName]: dependencyId }).catch(error => {
-        throw new Dynamo_Error({ 
-          status: 417, 
-          errorCode: 'NTS-DBS-DDD1',
-          addECToUserMsg: true,
-          message: `delete ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
-          error 
-        });
-      });
-    } else {
+    if (!this.depDataName) {
       throw new Dynamo_Error({ 
         status: 501, 
         errorCode: 'NTS-DBS-DDD0',
         addECToUserMsg: true,
         message: `dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`,
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+        userMessage: this.defaultErrorUserMsg
       });
     }
+
+    await this.dataModel.deleteMany({ [this.depDataName]: dependencyId })
+    .catch(error => {
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-DBS-DDD1',
+        addECToUserMsg: true,
+        message: `delete ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`, 
+        userMessage: this.defaultErrorUserMsg, 
+        error 
+      });
+    });
   }
 
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------
-  // DIRECT MONGOOSE CALLS (with error handlings)
+  // DIRECT Basic MONGOOSE FUNCTIONS (with error handlings)
 
   /**
-   * find the data first by any of its parameters, throws error if not found
-   * @param filter
-   * (always use unique parameters for find!)
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is GREATER THAN OR LESS THAN:
-   * @example { points: { $gt: 2, $lt: 14 } }
-   * further tools (syntax matches with $gt):
-   * $eq: Matches values that are EQUAL to a specified value.
-   * $gte: Matches values that are GREATER THAN or EQUAL to a specified value.
-   * $lte: Matches values that are LESS THAN or EQUAL to a specified value.
-   * $ne: Matches all values that are NOT EQUAL to a specified value.
-   * $nin: Matches NONE of the values specified IN an array.
+   * Find the data first by any of its parameters, throws error if not found
+   * @param filter if you can, use unique parameters for find!
    * 
-   * @returns data
+   * @example 
+   * // by email: 
+   * { email: email }
+   * //
+   * @example 
+   * // or by id that is in list:
+   * { userIds: { $in: this.userId } }
+   * //
+   * @example 
+   * // or by number or Date that is Greater Than AND Less Than:
+   * { points: { $gt: 2, $lt: 14 } }
+   * // further tools (syntax matches with $gt):
+   * $eq:  // Matches values that are EQual to a specified value.
+   * $gte: // Matches values that are Greater Than OR Equal to a specified value.
+   * $lte: // Matches values that are Less Than or Equal to a specified value.
+   * $ne:  // Matches all values that are Not Equal to a specified value.
+   * $nin: // Matches None of the values specified IN an array.
+   * //
+   * @returns {T} data: T
    */
   async findOne(filter: any): Promise<T> {
-    let data: T;
-    await this.dataModel.findOne(filter).then(res => {
+    let data: T = await this.dataModel.findOne(filter).then(res => {
       if (res) {
-        data = res.toObject() as T;
+        return res.toObject() as T;
       } else {
-        data = null;
+        return null;
       }
     }).catch(error => {
       throw new Dynamo_Error({ 
@@ -481,55 +470,61 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-FO0',
         addECToUserMsg: true,
         message: `findOne ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
+
     if (data && typeof data._id === 'object') {
       data._id = `${data._id}`;
     }
+
     return data;
   }
 
   /**
-   * find all data by any of its parameters, throws error if not found
-   * @param filter 
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is GREATER THAN OR LESS THAN:
-   * @example { points: { $gt: 2, $lt: 14 } }
-   * further tools (syntax matches with $gt):
-   * $eq: Matches values that are EQUAL to a specified value.
-   * $gte: Matches values that are GREATER THAN or EQUAL to a specified value.
-   * $lte: Matches values that are LESS THAN or EQUAL to a specified value.
-   * $ne: Matches all values that are NOT EQUAL to a specified value.
-   * $nin: Matches NONE of the values specified IN an array.
+   * Find the data first by any of its parameters, throws error if not found
+   * @param filter if you can, use unique parameters for find!
    * 
-   * @returns dataList
+   * @example 
+   * // by email: 
+   * { email: email }
+   * //
+   * @example 
+   * // or by id that is in list:
+   * { userIds: { $in: this.userId } }
+   * //
+   * @example 
+   * // or by number or Date that is Greater Than AND Less Than:
+   * { points: { $gt: 2, $lt: 14 } }
+   * // further tools (syntax matches with $gt):
+   * $eq:  // Matches values that are EQual to a specified value.
+   * $gte: // Matches values that are Greater Than OR Equal to a specified value.
+   * $lte: // Matches values that are Less Than or Equal to a specified value.
+   * $ne:  // Matches all values that are Not Equal to a specified value.
+   * $nin: // Matches None of the values specified IN an array.
+   * //
+   * @returns {T[]} dataList: T[]
    */
   async find(filter: any): Promise<T[]> {
-    let dataList = [];
-
-    await this.dataModel.find(filter).then(res => {
-      if (res) {
-        dataList = res;
-      }
-    }).catch(error => {
+    let dataList: T[] = await this.dataModel.find(filter)
+    .then(res => res ?? [])
+    .catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-F0',
         addECToUserMsg: true,
         message: `find ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
 
-    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+    if (0 < dataList.length) {
       dataList.forEach((data: T) => {
-        data._id = `˙${data._id}`;
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
       });
     }
 
@@ -537,50 +532,58 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
   }
 
   /**
-   * find all data by any of its parameters, throws error if not found
-   * @param filter
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is GREATER THAN OR LESS THAN:
-   * @example { points: { $gt: 2, $lt: 14 } }
-   * further tools (syntax matches with $gt):
-   * $eq: Matches values that are EQUAL to a specified value.
-   * $gte: Matches values that are GREATER THAN or EQUAL to a specified value.
-   * $lte: Matches values that are LESS THAN or EQUAL to a specified value.
-   * $ne: Matches all values that are NOT EQUAL to a specified value.
-   * $nin: Matches NONE of the values specified IN an array.
+   * Find the data first by any of its parameters, throws error if not found
+   * @param filter if you can, use unique parameters for find!
    * 
+   * @example 
+   * // by email: 
+   * { email: email }
+   * //
+   * @example 
+   * // or by id that is in list:
+   * { userIds: { $in: this.userId } }
+   * //
+   * @example 
+   * // or by number or Date that is Greater Than AND Less Than:
+   * { points: { $gt: 2, $lt: 14 } }
+   * // further tools (syntax matches with $gt):
+   * $eq:  // Matches values that are EQual to a specified value.
+   * $gte: // Matches values that are Greater Than OR Equal to a specified value.
+   * $lte: // Matches values that are Less Than or Equal to a specified value.
+   * $ne:  // Matches all values that are Not Equal to a specified value.
+   * $nin: // Matches None of the values specified IN an array.
+   * //
    * @param page page
    * @param pageSize pageSize
-   * @param sort etc. by dateTime: { dateTime: -1 }
-   * @returns dataList
+   * @param sort 
+   * @example
+   * // by dateTime (this uses the basic sort function): 
+   * { dateTime: -1 }
+   * //
+   * @returns {T[]} dataList: T[]
    */
   async findWithPaging(filter: any, page: number, pageSize: number, sort?: any): Promise<T[]> {
-    let dataList = [];
-    await this.dataModel.find(filter)
+    let dataList: T[] = await this.dataModel.find(filter)
                         .sort(sort)
                         .skip(page * pageSize)
                         .limit(pageSize)
-                        .then(res => {
-      if (res) {
-        dataList = res;
-      }
-    }).catch(error => {
+                        .then(res => res ?? [])
+    .catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-WP0',
         addECToUserMsg: true,
         message: `findWithPaging ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
 
-    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+    if (0 < dataList.length) {
       dataList.forEach((data: T) => {
-        data._id = `˙${data._id}`;
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
       });
     }
 
@@ -594,20 +597,19 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
    * @returns data
    */
   async findByIdAndUpdate(id: string, update: any, modifier: string): Promise<T> {
-    let data: T;
     update.__lastModified = new Date();
     update.__lastModifiedBy = modifier;
 
-    await this.dataModel.findByIdAndUpdate(id, update).then(res => {
+    let newData: T = await this.dataModel.findByIdAndUpdate(id, update).then(res => {
       if (res) {
-        data = res.toObject() as T;
+        return res.toObject() as T;
       } else {
         throw new Dynamo_Error({ 
           status: 204, 
           errorCode: 'NTS-DBS-FIU1',
           addECToUserMsg: true,
           message: `${this.dataParams.dbName} not found! (NTS DB)`,
-          userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`
+          userMessage: this.defaultErrorUserMsg
         });
       }
     }).catch(error => {
@@ -616,106 +618,184 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         errorCode: 'NTS-DBS-FIU0',
         addECToUserMsg: true,
         message: `findByIdAndUpdate ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error
       });
     });
-    update.__v = data.__v;
-    return update;
+
+    if (typeof newData._id === 'object') {
+      newData._id = `${newData._id}`;
+    }
+    /* update._id = newData._id;
+    update.__v = newData.__v; */
+
+    return newData;
   }
 
   /**
-   * update one parameter by a specific
-   * @param updateBy
-   * (always use unique parameters for find!)
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is GREATER THAN OR LESS THAN:
-   * @example { points: { $gt: 2, $lt: 14 } }
-   * further tools (syntax matches with $gt):
-   * $eq: Matches values that are EQUAL to a specified value.
-   * $gte: Matches values that are GREATER THAN or EQUAL to a specified value.
-   * $lte: Matches values that are LESS THAN or EQUAL to a specified value.
-   * $ne: Matches all values that are NOT EQUAL to a specified value.
-   * $nin: Matches NONE of the values specified IN an array.
+   * Find the data first by any of its parameters, throws error if not found
+   * @param filter This uses the basic Mongoose updateOne.
+   * If you can, use unique parameters for find!
+   * @example 
+   * // by email: 
+   * { email: email }
+   * //
+   * @example 
+   * // or by id that is in list:
+   * { userIds: { $in: this.userId } }
+   * //
+   * @example 
+   * // or by number or Date that is Greater Than AND Less Than:
+   * { points: { $gt: 2, $lt: 14 } }
+   * // further tools (syntax matches with $gt):
+   * $eq:  // Matches values that are EQual to a specified value.
+   * $gte: // Matches values that are Greater Than OR Equal to a specified value.
+   * $lte: // Matches values that are Less Than or Equal to a specified value.
+   * $ne:  // Matches all values that are Not Equal to a specified value.
+   * $nin: // Matches None of the values specified IN an array.
+   * //
    * 
-   * @param update
-   * etc.: increase a specific value:
-   * @example { $inc: { popularity: 15 } }
-   * or add element to a list:
-   * @example { $push: { reactions: this.newReaction }
-   * or all at once
-   * @example { $inc: { popularity: this.newVote.amount }, emailVerified: true, $push: { reactions: this.newReaction } }
-   * further tools (syntax matches with $inc):
-   * $currentDate: Sets the value of a field to current date, either as a Date or a Timestamp.
-   * $min: Only updates the field if the specified value is less than the existing field value.
-   * $max: Only updates the field if the specified value is greater than the existing field value.
-   * $mul: Multiplies the value of the field by the specified amount.
-   * $rename: Renames a field.
-   * $unset: Removes the specified field from a document. (set: "" to value)
+   * @param update this uses the basic Mongoose updateOne
+   * @example
+   * // increase a specific value (here by 15): 
+   * { $inc: { popularity: 15 } }
+   * //
+   * @example 
+   * // or add element to a list:
+   * { $push: { reactions: this.newReaction }
+   * // or add multiple elements to a list
+   * { $push: { schedule: {$each: [ monday, tuesday, wednesday ] } } }
+   * //
+   * @example 
+   * // or all at once 
+   * {  
+   *   $inc: { popularity: this.newVote.amount }, 
+   *   emailVerified: true, 
+   *   $push: { reactions: this.newReaction } 
+   * }
+   * // further tools (syntax matches with $inc):
+   * $currentDate: // Sets the value of a field to current date, either as a Date or a Timestamp.
+   * $min:         // Only updates the field if the specified value is less than the existing field value.
+   * $max:         // Only updates the field if the specified value is greater than the existing field value.
+   * $mul:         // Multiplies the value of the field by the specified amount.
+   * $rename:      // Renames a field.
+   * $unset:       // Removes the specified field from a document. (set: "" to value)
+   * //
    */
-  async updateOne(updateBy: any, update: any, modifier: string): Promise<void> {
+  async updateOne(updateBy: any, update: any, modifier: string): Promise<T> {
     update.__lastModified = new Date();
     update.__lastModifiedBy = modifier;
-    await this.dataModel.updateOne(updateBy, update).catch(error => {
-      throw new Dynamo_Error({ 
+    
+    let newData: T = await this.dataModel.updateOne(updateBy, update).then(res => {
+      if (res) {
+        return res.toObject() as T;
+      } else {
+        throw new Dynamo_Error({ 
+          status: 204, 
+          errorCode: 'NTS-DBS-FU1',
+          addECToUserMsg: true,
+          message: `update ${this.dataParams.dbName} result not found! (NTS DB)`,
+          userMessage: this.defaultErrorUserMsg
+        });
+      }
+    }).catch(error => {
+      throw new Dynamo_Error({
         status: 417, 
         errorCode: 'NTS-DBS-UO0',
         addECToUserMsg: true,
         message: `updateOne ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
+
+    if (typeof newData._id === 'object') {
+      newData._id = `${newData._id}`;
+    }
+    /* update._id = newData._id;
+    update.__v = newData.__v; */
+    console.log(`Dynamo function result under testing: ${newData}`);
+
+    return newData;
   }
 
   /**
    * update one parameter by a specific
-   * @param updateBy
-   * etc.: by email: 
-   * @example { email: email }
-   * or by id that is in list:
-   * @example { userIds: { $in: this.userId } }
-   * or by number or Date that is GREATER THAN OR LESS THAN:
-   * @example { points: { $gt: 2, $lt: 14 } }
-   * further tools (syntax matches with $gt):
-   * $eq: Matches values that are EQUAL to a specified value.
-   * $gte: Matches values that are GREATER THAN or EQUAL to a specified value.
-   * $lte: Matches values that are LESS THAN or EQUAL to a specified value.
-   * $ne: Matches all values that are NOT EQUAL to a specified value.
-   * $nin: Matches NONE of the values specified IN an array.
+   * @param filter This uses the basic Mongoose updateMany.
+   * @example 
+   * // by email: 
+   * { email: email }
+   * //
+   * @example 
+   * // or by id that is in list:
+   * { userIds: { $in: this.userId } }
+   * //
+   * @example 
+   * // or by number or Date that is Greater Than AND Less Than:
+   * { points: { $gt: 2, $lt: 14 } }
+   * // further tools (syntax matches with $gt):
+   * $eq:  // Matches values that are EQual to a specified value.
+   * $gte: // Matches values that are Greater Than OR Equal to a specified value.
+   * $lte: // Matches values that are Less Than or Equal to a specified value.
+   * $ne:  // Matches all values that are Not Equal to a specified value.
+   * $nin: // Matches None of the values specified IN an array.
+   * //
    * 
-   * @param update 
-   * etc.: increase a specific value:
-   * @example { $inc: { popularity: 15 } }
-   * or add element to a list:
-   * @example { $push: { reactions: this.newReaction }
-   * or all at once
-   * @example { $inc: { popularity: this.newVote.amount }, emailVerified: true, $push: { reactions: this.newReaction } }
-   * further tools (syntax matches with $inc):
-   * $currentDate: Sets the value of a field to current date, either as a Date or a Timestamp.
-   * $min: Only updates the field if the specified value is less than the existing field value.
-   * $max: Only updates the field if the specified value is greater than the existing field value.
-   * $mul: Multiplies the value of the field by the specified amount.
-   * $rename: Renames a field.
-   * $unset: Removes the specified field from a document. (set: "" to value)
+   * @param update this uses the basic Mongoose updateOne
+   * @example
+   * // increase a specific value (here by 15): 
+   * { $inc: { popularity: 15 } }
+   * //
+   * @example 
+   * // or add element to a list:
+   * { $push: { reactions: this.newReaction }
+   * // or add multiple elements to a list
+   * { $push: { schedule: {$each: [ monday, tuesday, wednesday ] } } }
+   * //
+   * @example 
+   * // or all at once 
+   * {
+   *   $inc: { popularity: this.newVote.amount }, 
+   *   emailVerified: true, 
+   *   $push: { reactions: this.newReaction } 
+   * }
+   * // further tools (syntax matches with $inc):
+   * $currentDate: // Sets the value of a field to current date, either as a Date or a Timestamp.
+   * $min:         // Only updates the field if the specified value is less than the existing field value.
+   * $max:         // Only updates the field if the specified value is greater than the existing field value.
+   * $mul:         // Multiplies the value of the field by the specified amount.
+   * $rename:      // Renames a field.
+   * $unset:       // Removes the specified field from a document. (set: "" to value)
+   * //
    */
-  async updateMany(updateBy: any, update: any, modifier: string): Promise<void> {
+  async updateMany(updateBy: any, update: any, modifier: string): Promise<T[]> {
     update.__lastModified = new Date();
     update.__lastModifiedBy = modifier;
 
-    await this.dataModel.updateMany(updateBy, update).catch(error => {
+    let dataList: T[] = await this.dataModel.updateMany(updateBy, update)
+    .then(res => res ?? [])
+    .catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-UM0',
         addECToUserMsg: true,
         message: `updateMany ${this.dataParams.dbName} was unsuccessful (NTS DB)`, 
-        userMessage: `We encountered an unhandled DB Error, please contact the responsible development team.`, 
+        userMessage: this.defaultErrorUserMsg, 
         error 
       });
     });
+
+    if (0 < dataList.length) {
+      dataList.forEach((data: T) => {
+        if (data && typeof data._id === 'object') {
+          data._id = `${data._id}`;
+        }
+      });
+    }
+    
+    console.log(`Dynamo function result under testing: ${dataList}`);
+
+    return dataList;
   }
 
   // ----------------------------------------------------------------------------------
@@ -754,7 +834,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
 
     params.forEach((property: DynamoNTS_DataPropertyParams) => {
       const beType = this.getBEType(property.type);
-      if (beType !== Object || !property.subObjectParams) {
+      if (beType !== Object || !property?.subObjectParams || property?.subObjectParams?.length == 0) {
         schemaSettingsObj[property.key] = {
           type: beType
         };