@futdevpro/nts-dynamo 1.5.81 → 1.5.83

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@futdevpro/nts-dynamo",
-  "version": "01.05.81",
+  "version": "01.05.83",
   "description": "Dynamic NodeTS (NodeJS-Typescript), MongoDB Backend System Framework by Future Development Program Ltd.",
-  "type": "module",
   "scripts": {
     "test": "jasmine",
 

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

@@ -1,7 +1,7 @@
 
 import { Dynamo_Metadata, Dynamo_DataParams, Dynamo_DataPropertyParams, Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
-import { DynamoNTS_DBService } from './dynamo-nts-db.service';
+import { DynamoNTS_DBFilter, DynamoNTS_DBService, DynamoNTS_DBUpdate } from './dynamo-nts-db.service';
 import { DynamoNTS_GlobalService } from './dynamo-nts-global.service';
 
 /**
@@ -285,9 +285,9 @@ export class DynamoNTS_DataService<T extends Dynamo_Metadata> {
    * //
    * @returns {T} data: T
    */
-  async findData(findBy: any, dontSetToService?: boolean): Promise<T> {
+  async findData(filterBy: DynamoNTS_DBFilter<T>, dontSetToService?: boolean): Promise<T> {
     try {
-      const dataExists: T = await this.dataDBService.findOne(findBy).catch(error => {
+      const dataExists: T = await this.dataDBService.findOne(filterBy).catch(error => {
         if (error?.errorCode === 'NTS-DBS-FO1') {
           Dynamo_Log.warn(`findData ${this.dataParams.dataName} didn't found any.`);
           return null;
@@ -342,9 +342,9 @@ export class DynamoNTS_DataService<T extends Dynamo_Metadata> {
    * //
    * @returns {T[]} dataList: T[]
    */
-  async findDatas(findBy: any, dontSetToService?: boolean): Promise<T[]> {
+  async findDatas(filterBy: DynamoNTS_DBFilter<T>, dontSetToService?: boolean): Promise<T[]> {
     try {
-      const dataListExists: T[] = await this.dataDBService.find(findBy).catch(error => {
+      const dataListExists: T[] = await this.dataDBService.find(filterBy).catch(error => {
         if (error?.errorCode === 'NTS-DBS-F1') {
           Dynamo_Log.warn(`findDatas ${this.dataParams.dataName} didn't found any.`);
           return [];
@@ -425,14 +425,14 @@ export class DynamoNTS_DataService<T extends Dynamo_Metadata> {
    * $unset:       // Removes the specified field from a document. (set: "" to value)
    * //
    */
-  async updateData(set: { updateBy?: any, update: any }): Promise<void> {
+  async updateData(set: { filterBy?: DynamoNTS_DBFilter<T>, update: DynamoNTS_DBUpdate<T> }): Promise<void> {
     try {
-      if (set.updateBy) {
-        await this.dataDBService.updateOne(set.updateBy, set.update, this.issuer);
+      if (set.filterBy) {
+        await this.dataDBService.updateOne(set.filterBy, set.update, this.issuer);
       } else if (this.data._id) {
-        await this.dataDBService.updateOne({ _id: this.data._id }, set.update, this.issuer);
+        await this.dataDBService.updateOne({ _id: this.data._id } as DynamoNTS_DBFilter<T>, set.update, this.issuer);
       } else if (this.depKey && this.data[this.depKey]) {
-        await this.dataDBService.updateOne({ [this.depKey]: this.data[this.depKey] }, set.update, this.issuer);
+        await this.dataDBService.updateOne({ [this.depKey]: this.data[this.depKey] } as DynamoNTS_DBFilter<T>, set.update, this.issuer);
       } else {
         throw new Dynamo_Error({
           status: 417, 

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

@@ -6,10 +6,87 @@ import {
   Dynamo_Metadata, Dynamo_DataParams, Dynamo_DataPropertyParams, Dynamo_Error 
 } from '@futdevpro/fsm-dynamo';
 
+/**
+ * @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
+ */
+export type DynamoNTS_DBFilter<T> = {
+  [K in keyof T]?: T[K] | { 
+    $in?: any,            // Matches values that are includes the value; This works only when T[K] is an array!
+    $eq?: T[K],           // Matches values that are EQual to a specified value.
+    $gt?: number | Date,  // Matches values that are Greater Than a specified value.
+    $gte?: number | Date, // Matches values that are Greater Than OR Equal to a specified value.
+    $lt?: number | Date,  // Matches values that are Less Than a specified value.
+    $lte?: number | Date, // Matches values that are Less Than or Equal to a specified value.
+    $ne?: T[K],           // Matches all values that are Not Equal to a specified value.
+    $nin?: T[K],          // Matches None of the values specified IN an array.
+  };
+};
+
+/**
+ * @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)
+ * //
+ */
+export type DynamoNTS_DBUpdate<T> = {
+  [K in keyof T]?: T[K] | {
+    $inc?: number,    // Increments the value of the field by the specified amount.
+    $push?: any | {   // Adds an item to an array. 
+      $each?: T[K],   // Adds multiple items to an array.
+    },                // or add multiple elements to a list
+                      // { $push: { schedule: {$each: [ monday, tuesday, wednesday ] } } }
+    $min?: number,    // Only updates the field if the specified value is less than the existing field value.
+    $max?: number,    // Only updates the field if the specified value is greater than the existing field value.
+    $mul?: number,    // Multiplies the value of the field by the specified amount.
+    $rename?: string, // Renames a field.
+    $unset?: string,  // Removes the specified field from a document. (set: "" to value)
+  };
+};
+
 /**
  * 
  */
-export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U extends T = any> {
+export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
   dataModel = mongoose.model(this.dataParams.dbName, this.getSchema());
 
   private depDataName: string;
@@ -269,15 +346,89 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
     return dataList;
   }
 
+  /**
+   * returns all data from database, 
+   * !!!: throws error if not found (errorCode on not found: NTS-DBS-GA1)
+   * 
+   * @returns dataList
+   */
+  async getAll(): Promise<T[]> {
+    let dataList: T[] = await this.dataModel.find({})
+    .then(res => {
+      return res as T[] ?? [];
+    }).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: this.defaultErrorUserMsg, 
+        error 
+      });
+    });
+
+    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
+      dataList.forEach((data: T) => {
+        data._id = `˙${data._id}`;
+      });
+    }
+
+    return dataList as T[];
+  }
+
+  /**
+   * deleted data by id
+   * @param id id
+   */
+  async deleteDataById(id: string): Promise<void> {
+    await this.dataModel.findByIdAndDelete(id).catch(error => {
+      throw new Dynamo_Error({ 
+        status: 417, 
+        errorCode: 'NTS-DBS-DD0',
+        addECToUserMsg: true,
+        message: `delete ${this.dataParams.dbName} was unsuccessful (NTS DB)`,
+        userMessage: this.defaultErrorUserMsg,  
+        error 
+      });
+    });
+  }
+
+  /**
+   * deleted data by id
+   * @param dependencyId id
+   */
+  async deleteDataByDependencyId(dependencyId: string): Promise<void> {
+    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: 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 
+      });
+    });
+  }
+
   /**
    * returns search result for searchBy object params
    * can use lists or xRange values for searchBy obj properties
    * 
-   * @param searchBy filter
+   * @param filterBy filter
    * @param narrowByDependencyIds id
    * @returns dataList
    */
-  async searchData(searchBy: F, narrowByDependencyIds?: string[]): Promise<T[]> {
+  async searchData(filterBy: DynamoNTS_DBFilter<T>, narrowByDependencyIds?: string[]): Promise<T[]> {
     const filter = {};
 
     if (0 < narrowByDependencyIds.length) {
@@ -296,45 +447,45 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
 
     await this.dataParams.modelParams.forEach((modelParam: Dynamo_DataPropertyParams) => {
       if (
-        (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) || 
-        searchBy[modelParam.key + 'Range']
+        (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) || 
+        filterBy[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
+              filterBy[searchParamKeyWithoutRange] !== null && 
+              filterBy[searchParamKeyWithoutRange] !== undefined
             ) {
               filter[modelParam.key] = {
-                from: { $lte: searchBy[searchParamKeyWithoutRange] },
-                to: { $gte: searchBy[searchParamKeyWithoutRange] }
+                from: { $lte: filterBy[searchParamKeyWithoutRange] },
+                to: { $gte: filterBy[searchParamKeyWithoutRange] }
               };
             }
           } else {
             if (
-              searchBy[modelParam.key] !== null && 
-              searchBy[modelParam.key] !== undefined
+              filterBy[modelParam.key] !== null && 
+              filterBy[modelParam.key] !== undefined
             ) {
-              filter[modelParam.key] = { $in: searchBy[modelParam.key] };
+              filter[modelParam.key] = { $in: filterBy[modelParam.key] };
             }
           }
         } else {
           // basic search filter
-          if (searchBy[modelParam.key + 'Range']) {
-            if (searchBy[modelParam.key + 'Range'].from || searchBy[modelParam.key + 'Range'].to) {
+          if (filterBy[modelParam.key + 'Range']) {
+            if (filterBy[modelParam.key + 'Range'].from || filterBy[modelParam.key + 'Range'].to) {
               filter[modelParam.key] = {};
-              if (searchBy[modelParam.key + 'Range'].from) {
-                filter[modelParam.key].$gte = searchBy[modelParam.key + 'Range'].from;
+              if (filterBy[modelParam.key + 'Range'].from) {
+                filter[modelParam.key].$gte = filterBy[modelParam.key + 'Range'].from;
               }
-              if (searchBy[modelParam.key + 'Range'].to) {
-                filter[modelParam.key].$lte = searchBy[modelParam.key + 'Range'].to;
+              if (filterBy[modelParam.key + 'Range'].to) {
+                filter[modelParam.key].$lte = filterBy[modelParam.key + 'Range'].to;
               }
             }
-          } else if (searchBy[modelParam.key] !== null && searchBy[modelParam.key] !== undefined) {
-            if (searchBy[modelParam.key].lenght > 0) {
-              filter[modelParam.key] = { $in: searchBy[modelParam.key] };
+          } else if (filterBy[modelParam.key] !== null && filterBy[modelParam.key] !== undefined) {
+            if (filterBy[modelParam.key].lenght > 0) {
+              filter[modelParam.key] = { $in: filterBy[modelParam.key] };
             }
           }
         }
@@ -365,80 +516,6 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
     return dataList;
   }
 
-  /**
-   * returns all data from database, 
-   * !!!: throws error if not found (errorCode on not found: NTS-DBS-GA1)
-   * 
-   * @returns dataList
-   */
-  async getAll(): Promise<T[]> {
-    let dataList: T[] = await this.dataModel.find({})
-    .then(res => {
-      return res as T[] ?? [];
-    }).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: this.defaultErrorUserMsg, 
-        error 
-      });
-    });
-
-    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
-      dataList.forEach((data: T) => {
-        data._id = `˙${data._id}`;
-      });
-    }
-
-    return dataList as T[];
-  }
-
-  /**
-   * deleted data by id
-   * @param id id
-   */
-  async deleteDataById(id: string): Promise<void> {
-    await this.dataModel.findByIdAndDelete(id).catch(error => {
-      throw new Dynamo_Error({ 
-        status: 417, 
-        errorCode: 'NTS-DBS-DD0',
-        addECToUserMsg: true,
-        message: `delete ${this.dataParams.dbName} was unsuccessful (NTS DB)`,
-        userMessage: this.defaultErrorUserMsg,  
-        error 
-      });
-    });
-  }
-
-  /**
-   * deleted data by id
-   * @param dependencyId id
-   */
-  async deleteDataByDependencyId(dependencyId: string): Promise<void> {
-    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: 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 
-      });
-    });
-  }
-
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------
   // ----------------------------------------------------------------------------------
@@ -448,7 +525,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * Find the data first by any of its parameters, 
    * !!!: throws error if not found (errorCode on not found: NTS-DBS-FO1)
    * 
-   * @param filter if you can, use unique parameters for find!
+   * @param filterBy if you can, use unique parameters for find!
    * 
    * @example 
    * // by email: 
@@ -470,15 +547,15 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * //
    * @returns {T} data: T
    */
-  async findOne(filter: F): Promise<T> {
-    let data: T = await this.dataModel.findOne(filter).then(res => {
+  async findOne(filterBy: DynamoNTS_DBFilter<T>): Promise<T> {
+    let data: T = await this.dataModel.findOne(filterBy).then(res => {
       return res as T ?? null;
     }).catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-FO0',
         addECToUserMsg: true,
-        message: `findOne ${this.dataParams.dbName} was unsuccessful (NTS DB) fliter: ${filter}`, 
+        message: `findOne ${this.dataParams.dbName} was unsuccessful (NTS DB) fliter: ${filterBy}`, 
         userMessage: this.defaultErrorUserMsg, 
         error 
       });
@@ -496,7 +573,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * Find the data first by any of its parameters, 
    * !!!: throws error if not found (errorCode on not found: NTS-DBS-F1)
    * 
-   * @param filter if you can, use unique parameters for find!
+   * @param filterBy if you can, use unique parameters for find!
    * 
    * @example 
    * // by email: 
@@ -518,8 +595,8 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * //
    * @returns {T[]} dataList: T[]
    */
-  async find(filter: F): Promise<T[]> {
-    let dataList: T[] = await this.dataModel.find(filter)
+  async find(filterBy: DynamoNTS_DBFilter<T>): Promise<T[]> {
+    let dataList: T[] = await this.dataModel.find(filterBy)
     .then(res => {
       return res as T[] ?? [];
     }).catch(error => {
@@ -548,7 +625,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * #MONGOOSE FUNCTION
    * Find the data first by any of its parameters
    * 
-   * @param filter if you can, use unique parameters for find!
+   * @param filterBy if you can, use unique parameters for find!
    * 
    * @example 
    * // by email: 
@@ -577,8 +654,8 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * //
    * @returns {T[]} dataList: T[]
    */
-  async findWithPaging(filter: F, page: number, pageSize: number, sort?: any): Promise<T[]> {
-    let dataList: T[] = await this.dataModel.find(filter)
+  async findWithPaging(filterBy: DynamoNTS_DBFilter<T>, page: number, pageSize: number, sort?: any): Promise<T[]> {
+    let dataList: T[] = await this.dataModel.find(filterBy)
                         .sort(sort)
                         .skip(page * pageSize)
                         .limit(pageSize)
@@ -614,7 +691,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * @param update update
    * @returns data
    */
-  async findByIdAndUpdate(id: string, update: U, modifier: string): Promise<T> {
+  async findByIdAndUpdate(id: string, update: DynamoNTS_DBUpdate<T>, modifier: string): Promise<T> {
     update.__lastModified = new Date();
     update.__lastModifiedBy = modifier;
 
@@ -690,11 +767,11 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * $unset:       // Removes the specified field from a document. (set: "" to value)
    * //
    */
-  async updateOne(updateBy: F, update: U, issuer: string): Promise<void> {
+  async updateOne(filterBy: DynamoNTS_DBFilter<T>, update: DynamoNTS_DBUpdate<T>, issuer: string): Promise<void> {
     update.__lastModified = new Date();
     update.__lastModifiedBy = issuer;
     
-    await this.dataModel.updateOne(updateBy, update).catch(error => {
+    await this.dataModel.updateOne(filterBy, update).catch(error => {
       throw new Dynamo_Error({
         status: 417, 
         errorCode: 'NTS-DBS-UO0',
@@ -757,11 +834,11 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata, F extends T = any, U
    * $unset:       // Removes the specified field from a document. (set: "" to value)
    * //
    */
-  async updateMany(updateBy: F, update: U, issuer: string): Promise<void> {
+  async updateMany(filterBy: DynamoNTS_DBFilter<T>, update: DynamoNTS_DBUpdate<T>, issuer: string): Promise<void> {
     update.__lastModified = new Date();
     update.__lastModifiedBy = issuer;
 
-    await this.dataModel.updateMany(updateBy, update).catch(error => {
+    await this.dataModel.updateMany(filterBy, update).catch(error => {
       throw new Dynamo_Error({ 
         status: 417, 
         errorCode: 'NTS-DBS-UM0',