@futdevpro/nts-dynamo 1.6.55 → 1.6.59

package/src/_constants/global-settings.const.ts

@@ -18,5 +18,8 @@ export const dynamoNTS_globalSettings: DynamoNTS_GlobalSettings = {
   logMainSocketEvents: true,
   logSocketEventContent: false,
 
-  logDetailedApiEvents: true,
+  logApiEvents: true,
+  logApiRequestContents: false,
+  logApiRequestSettings: false,
+  logApiResponseContents: false,
 };

package/src/_enums/http/socket-event-type.enum.ts

@@ -9,6 +9,8 @@ export enum DynamoNTS_SocketEventKey {
   subscriptionSuccessful = 'subscriptionSuccessful',
   unsubscribe = 'unsubscribe',
   disconnect = 'disconnection',
+  
+  ping = 'ping',
   event = 'event',
   error = 'error',
 }

package/src/_models/control-models/app-params.control-model.ts

@@ -10,50 +10,36 @@ export class DynamoNTS_AppParams {
   /**
    * title will be shown on the start of the application
    */
-  title: string;
+  title?: string;
   /**
    * version of the application
+   * you should set the version,
+   * probably, you should set from the package.json as follows:
+   * import { version } from '../package.json';
    */
   version: string;
   /**
    * name of your MongoDB table
+   * by default, its: `mongodb://localhost:27017/${this.dbName}`
    */
-  dbUri: string;
+  dbUri?: string;
   /**
-   * mongoDB uri, by default, its: `mongodb://localhost:27017/${this.dbName}`
+   * name of your MongoDB table
    */
   dbName: string;
+  /**
+   * name of the system, by default, its: this.name.replace(' ', '-')
+   */
+  systemName?: string;
 
   constructor(
-    set: {
-      /**
-       * name the application
-       */
-      name: string,
-      /**
-       * you can set a big f*in title to show on the start of the application
-       */
-      title?: string,
-      /**
-       * you should set the version,
-       * probably, you should set from the package.json as follows:
-       * import { version } from '../package.json';
-       */
-      version: string,
-      /**
-       * You need to name your MongoDB table
-       */
-      dbName: string,
-      /**
-       * you can change the mongoDB uri here. by default, its: `mongodb://localhost:27017/${this.dbName}`
-       */
-      dbUri?: string,
-    }
+    set: DynamoNTS_AppParams
   ) {
     this.name = set.name;
     this.title = set.title ?? '';
     this.version = set.version;
     this.dbName = set.dbName;
     this.dbUri = set.dbUri ?? `mongodb://localhost:27017/${this.dbName}`;
+    this.systemName = set.systemName ?? this.name.replace(' ', '-');
   }
 }

package/src/_models/control-models/endpoint-params.control-model.ts

@@ -26,6 +26,7 @@ export class DynamoNTS_EndpointParams{
   private tasks: ((req: Request, res: Response, issuer?: string) => Promise<void>)[];
 
   private logRequest: boolean;
+  private logRequestsParams: boolean;
   private logRequestsContent: boolean;
   private logResponseContent: boolean;
 
@@ -68,6 +69,10 @@ export class DynamoNTS_EndpointParams{
        * this flag will enable the debug logs on this endpoint
        */
       logRequest?: boolean,
+      /**
+       * this flag will enable the debug logs on this endpoint's requests
+       */
+      logRequestsParams?: boolean,
       /**
        * this flag will enable the debug logs on this endpoint's requests
        */
@@ -104,11 +109,15 @@ export class DynamoNTS_EndpointParams{
       this.tasks = set.tasks;
 
       this.logRequest = set.logRequest ?? dynamoNTS_globalSettings.logRequest;
+      this.logRequestsParams = set.logRequestsParams ?? dynamoNTS_globalSettings.logRequestsParams;
       this.logRequestsContent = set.logRequestsContent ?? dynamoNTS_globalSettings.logRequestsContent;
-      /* this.logResponseContent = set.logResponseContent ?? dynamoNTS_globalSettings.logResponseContent; */
+      this.logResponseContent = set.logResponseContent ?? dynamoNTS_globalSettings.logResponseContent;
     } catch (error) {
       Dynamo_Log.error(
-        `\nEndpoint params setup failed: name: '${set.name}' (security: ${set.security}) endpoint: ${set.endpoint}\nERROR:\n`, error);
+        `\nEndpoint params setup failed: name: '${set.name}' (security: ${set.security}) endpoint: ${set.endpoint}` +
+        `\nERROR:` +
+        `\n`, error
+      );
       throw error;
     }
   }
@@ -120,17 +129,37 @@ export class DynamoNTS_EndpointParams{
   private async preLog(req: Request, res: Response, issuer: string): Promise<void> {
     try {
       if (this.logRequest) {
-        if (this.logRequestsContent) {
+        let msg: string = `===>   incoming ${this.name} request... (issuer: ${issuer})`;
+
+        if (this.logRequestsParams) {
+          const params = this.getPathParamsLogContent(req);
+          msg += `\npathParams: ${params}`;
+        }
+
+        if (this.logRequestsContent && req.body && 0 < Object.keys(req.body).length) {
+          Dynamo_Log.info(msg + `\nbody:`, req.body);
+        } else {
+          Dynamo_Log.info(msg);
+        }
+
+        /* if (this.logRequestsContent) {
           const params = this.getPathParamsLogContent(req);
 
           if (req.body && 0 < Object.keys(req.body).length) {
-            console.log(`===> incoming ${this.name} request... (issuer: ${issuer})\npathParams:${params}\nbody:`, req.body);
+            console.log(
+              `===>   incoming ${this.name} request... (issuer: ${issuer})` +
+              `\npathParams: ${params}` +
+              `\nbody:`, req.body
+            );
           } else {
-            console.log(`===> incoming ${this.name} request... (issuer: ${issuer})\npathParams:${params}`);
+            console.log(
+              `===>   incoming ${this.name} request... (issuer: ${issuer})` +
+              `\npathParams: ${params}`
+            );
           }
         } else {
-          console.log(`===> incoming ${this.name} request...`);
-        }
+          console.log(`===>   incoming ${this.name} request...`);
+        } */
       }
 
     } catch (error) {

package/src/_models/control-models/socket-event.control-model.ts

@@ -96,7 +96,10 @@ export class DynamoNTS_SocketEvent<T>{
   private async getPreLog(content: T, issuer?: string): Promise<void> {
     try {
       if (this.logEventContent && this.eventKey !== DynamoNTS_SocketEventKey.connection) {
-        Dynamo_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey};\ncontent:`, content);
+        Dynamo_Log.log(
+          `--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
+          \ncontent:`, content
+        );
       } else {
         Dynamo_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey}...`);
       }

package/src/_models/control-models/socket-presence.control-model.ts

@@ -53,7 +53,10 @@ export class DynamoNTS_SocketPresence {
 
     this.sockets.forEach((socket: SocketIO.Socket, index: number) => {
       if (!socket.connected) {
-        Dynamo_Log.error(`Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!\nERROR: socket[${socket.id}] is not connected! (it will be removed...)`);
+        Dynamo_Log.warn(
+          `Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!` +
+          `\nERROR: socket[${socket.id}] is not connected! (it will be removed...)`
+        );
 
         /* errors.push(
           new Dynamo_Error({
@@ -74,7 +77,10 @@ export class DynamoNTS_SocketPresence {
 
     this.sockets.forEach((socket: SocketIO.Socket, index: number) => {
       const success: boolean = socket.emit(event, content, error => {
-        Dynamo_Log.error(`Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!(0)\nerror:`, error);
+        Dynamo_Log.error(
+          `Emitting event '${event}' on socket(${this.serviceName})-(${index}) failed!(0)` +
+          `\nerror:`, error
+        );
         errors.push(error);
       });
 

package/src/_models/interfaces/global-settings.interface.ts

@@ -33,6 +33,10 @@ export interface DynamoNTS_GlobalSettings {
    * this is an application wide default setting for route debug logs
    */
   logRequest?: boolean;
+  /**
+   * this is an application wide default setting for route debug logs
+   */
+  logRequestsParams?: boolean;
   /**
    * this is an application wide default setting for route debug logs
    */
@@ -58,5 +62,17 @@ export interface DynamoNTS_GlobalSettings {
   /**
    * this is an application wide default setting for api debug logs
    */
-  logDetailedApiEvents?: boolean;
+  logApiEvents?: boolean;
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  logApiRequestContents?: boolean;
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  logApiRequestSettings?: boolean;
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  logApiResponseContents?: boolean;
 }

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

@@ -148,6 +148,38 @@ export class DynamoNTS_DataService<T extends Dynamo_Metadata> {
       }
     }
   }
+
+  async getDataByIds(ids: string[], dontSetToService?: boolean): Promise<T[]> {
+    try {
+      if (!ids) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'getDataByIds',
+            new Error(`getDataByIds failed, ids is missing! (${this.dataParams.dataName})`)
+          ),
+
+          errorCode: 'NTS-DS0-GIS1',
+        });
+      }
+
+      if (ids.length === 0) {
+        return [];
+      }
+
+      const datas: T[] = await this.dataDBService.find({ _id: { $in: ids, }, });
+      if (!dontSetToService) {
+        this.dataList = datas;
+      }
+
+      return datas;
+    } catch (error) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('getDataByIds', error),
+
+        errorCode: 'NTS-DS0-GIS0',
+      });
+    }
+  }
   
   /**
    * returns data from database by dependencyId to the service
@@ -203,6 +235,53 @@ export class DynamoNTS_DataService<T extends Dynamo_Metadata> {
       }
     }
   }
+
+  async getDatasByDependencyIds(dependencyIds: string[], dontSetToService?: boolean): Promise<T[]> {
+    try {
+      if (!this.depKey) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'getDatasByDependencyIds',
+            new Error(`getDatasByDependencyIds failed, dependencyKey is missing from service! (${this.dataParams.dataName})`)
+          ),
+
+          errorCode: 'NTS-DS0-GDS1',
+        });
+      }
+
+      if (!dependencyIds) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'getDatasByDependencyIds',
+            new Error(`getDatasByDependencyIds failed, dependencyIds is missing! (${this.dataParams.dataName})`)
+          ),
+
+          errorCode: 'NTS-DS0-GDS2',
+        });
+      }
+
+      if (dependencyIds.length === 0) {
+        return [];
+      }
+
+      const datas: T[] = await this.dataDBService.getDatasByDependencyIds(dependencyIds);
+      if (!dontSetToService) {
+        this.dataList = datas;
+      }
+
+      return datas;
+    } catch (error) {
+      if ([ 'NTS-DS0-GDS1', 'NTS-DS0-GDS2' ].includes(error?.errorCode)) {
+        throw error;
+      } else {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings('getDatasByDependencyIds', error),
+
+          errorCode: 'NTS-DS0-GDS0',
+        });
+      }
+    }
+  }      
   
   /**
    * returns dataList from database by dependencyId to the service

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

@@ -244,12 +244,41 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    if (0 < dataList.length) {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'getDataListByDependencyId');
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'getDataListByDependencyId');
+    });
+
+    return dataList;
+  }
+
+  async getDatasByDependencyIds(dependencyIds: string[]): Promise<T[]> {
+    if (!this.depDataName) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'getDatasByDependencyIds',
+          new Error(`dependencyDataIdKey not setted up for this db-service (${this.dataParams.dbName}) (NTS DB)`)
+        ),
+
+        status: 501,
+        errorCode: 'NTS-DBS-GLDS0',
       });
     }
 
+    let dataList: T[] = await this.dataModel.find({ [this.depDataName]: { $in: dependencyIds }}).then(res => {
+      return res as T[] ?? [];
+    }).catch(error => {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings('getDatasByDependencyIds', error),
+
+        errorCode: 'NTS-DBS-GLDS1',
+        message: `get ${this.dataParams.dbName} by ${this.depDataName} was unsuccessful (NTS DB)`,
+      });
+    });
+
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'getDatasByDependencyIds');
+    });
+
     return dataList;
   }
 
@@ -284,11 +313,9 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    if (0 < dataList.length) {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'getDataListByDependencyIds');
-      });
-    }
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'getDataListByDependencyIds');
+    });
 
     return dataList;
   }
@@ -312,11 +339,9 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    if (0 < dataList.length && typeof dataList[0]._id === 'object') {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'getAll');
-      });
-    }
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'getAll');
+    });
 
     return dataList as T[];
   }
@@ -449,11 +474,9 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         });
       });
 
-    if (0 < dataList.length) {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'searchData');
-      });
-    }
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'searchData');
+    });
 
     return dataList;
   }
@@ -546,11 +569,9 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    if (0 < dataList.length) {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'find');
-      });
-    }
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'find');
+    });
 
     return dataList as T[];
   }
@@ -603,11 +624,9 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    if (0 < dataList.length) {
-      dataList.forEach((data: T) => {
-        data = this.stringifyDataId(data, 'findWithPaging');
-      });
-    }
+    dataList.forEach((data: T) => {
+      data = this.stringifyDataId(data, 'findWithPaging');
+    });
 
     return dataList;
   }

package/src/_services/core/api.service.ts

@@ -101,6 +101,21 @@ export class DynamoNTS_ApiService {
             callParams.httpOptions.params = httpParams;
         } */
 
+        if (dynamoNTS_globalSettings.logApiEvents) {
+            if (dynamoNTS_globalSettings.logApiRequestContents) {
+                Dynamo_Log.log(`<      outgoing API call: ${url} \nbody:`, inputParams?.body);
+            } else {
+                Dynamo_Log.log(`<      outgoing API call: ${url}`);
+            }
+            if (dynamoNTS_globalSettings.logApiRequestSettings) {
+                Dynamo_Log.log(`callParams:`, callParams);
+                Dynamo_Log.log('inputParams:', { 
+                    pathParams: inputParams.pathParams ?? {}, 
+                    body: inputParams.body ?? null 
+                });
+            }
+        }
+
         switch (callParams.type) {
             case DynamoNTS_HttpCallType.get:
                 if (inputParams?.body) {
@@ -113,10 +128,12 @@ export class DynamoNTS_ApiService {
                         a = res.data;
                     }
 
-                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
-                        Dynamo_Log.success(`${callParams.name} was successful`, res.data);
-                    } else {
-                        Dynamo_Log.success(`${callParams.name} was successful`);
+                    if (dynamoNTS_globalSettings.logApiEvents) {
+                        if (dynamoNTS_globalSettings.logApiResponseContents) {
+                            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+                        } else {
+                            Dynamo_Log.success(`${callParams.name} was successful`);
+                        }
                     }
                 });
             break;
@@ -129,10 +146,12 @@ export class DynamoNTS_ApiService {
                         a = res;
                     }
 
-                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
-                        Dynamo_Log.success(`${callParams.name} was successful`, res.data);
-                    } else {
-                        Dynamo_Log.success(`${callParams.name} was successful`);
+                    if (dynamoNTS_globalSettings.logApiEvents) {
+                        if (dynamoNTS_globalSettings.logApiResponseContents) {
+                            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+                        } else {
+                            Dynamo_Log.success(`${callParams.name} was successful`);
+                        }
                     }
                 });
             break;
@@ -152,10 +171,12 @@ export class DynamoNTS_ApiService {
                         a = res.data;
                     }
 
-                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
-                        Dynamo_Log.success(`${callParams.name} api call was successful`, res.data);
-                    } else {
-                        Dynamo_Log.success(`${callParams.name} api call was successful`);
+                    if (dynamoNTS_globalSettings.logApiEvents) {
+                        if (dynamoNTS_globalSettings.logApiResponseContents) {
+                            Dynamo_Log.success(`>      ${callParams.name} api call was successful`, res.data);
+                        } else {
+                            Dynamo_Log.success(`>      ${callParams.name} api call was successful`);
+                        }
                     }
                 });
             break;
@@ -170,8 +191,11 @@ export class DynamoNTS_ApiService {
             return a as T;
         }
     } catch (error) {
-        Dynamo_Log.error(`\nAPI ERROR: ${callParams?.name} failed...` +
-        `\n${callParams?.baseUrl}${callParams?.endPoint}\ncallParams:`, callParams);
+        Dynamo_Log.error(
+            `\n>      API ERROR: ${callParams?.name} failed...` +
+            `\n${callParams?.baseUrl}${callParams?.endPoint}` +
+            `\ncallParams:`, callParams
+        );
 
         if (callParams?.httpOptions?.responseType === DynamoNTS_HttpResponseType.text) {
             error.error = JSON.parse(error.error);

package/src/_services/core/global.service.ts

@@ -37,8 +37,10 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
   dbServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_DBService<any>>; // DynamoNTS_DBServiceCollection;
   emailServiceCollection: DynamoNTS_ServiceCollection<DynamoNTS_EmailService>; // DynamoNTS_EmailServiceCollection;
 
-  private static _globalErrorHandler?: (err: any, req: Request, res: Response, issuer: string) => Promise<void>;
-  static get globalErrorHandler(): (err: any, req: Request, res: Response, issuer: string) => Promise<void> { return this._globalErrorHandler; }
+  private static _globalErrorHandler?: (err: any, req?: Request, res?: Response, issuer?: string) => Promise<void>;
+  static get globalErrorHandler(): (err: any, req?: Request, res?: Response, issuer?: string) => Promise<void> { 
+    return this._globalErrorHandler; 
+  }
   
   /**
    * You need to setup global Services through this function

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

@@ -166,7 +166,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
         console.log(this.params.title);
         console.log(`Version: ${this.params.version}`);
       }
-      Dynamo_Log.testSuccess(`${this.params.name} started successfully.`);
+      Dynamo_Log.H_success(`${this.params.name} started successfully.`);
       
     } catch (error) {
       Dynamo_Log.error(`\nExtended Application: ${this.params?.name} start failed.\n`, error, '\n');
@@ -300,7 +300,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       this.systemControlsExt.httpSocketServer.init = false;
       this.systemControlsExt.httpsSocketServer.init = false;
 
-      Dynamo_Log.test(`${this.params.name} stopped successfully.`);
+      Dynamo_Log.H_info(`${this.params.name} stopped successfully.`);
     }
   }
 

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

@@ -223,6 +223,26 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
   constructor(extended?: boolean){
     super();
+    
+    process.on('unhandledRejection', (reason: object, p: any) => {
+      Dynamo_Log.highlightedError(
+        'Unhandled Rejection at: ', p, 
+        '\nRejection reason:', reason
+      );
+
+      try {
+        DynamoNTS_GlobalService.globalErrorHandler?.(
+          new Dynamo_Error({
+            errorCode: 'NTS-AS0-BASE-UR',
+            message: 'Unhandled Rejection!',
+            error: new Error(p),
+          })
+        );
+
+      } catch (error) {
+        Dynamo_Log.error('getGlobalErrorHandler ERROR:', error);
+      }
+    });
 
     this.asyncConstruct(extended).catch((error: any) => {
       Dynamo_Log.error(`\nApplication: ${this._params.name} start failed.\n`, error);
@@ -234,11 +254,11 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
     try {
       this.systemControls.app.init = true;
       this._params = this.getAppParams();
-      dynamo_error_default.issuerSystem = this._params.name;
+
+      dynamo_error_default.issuerSystem = this._params.systemName;
       
-      if (this.overrideDynamoNTSGlobalSettings) {
-        this.overrideDynamoNTSGlobalSettings();        
-      } 
+      this.overrideDynamoNTSGlobalSettings?.();        
+
       this.logSetup = dynamoNTS_globalSettings.logSetup;
       
       this.globalService = DynamoNTS_GlobalService.getInstance();
@@ -258,9 +278,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         this._routingModules = this.getRoutingModules();
       }
 
-      if (this.createEntries) {
-        await this.createEntries();
-      }
+      await this.createEntries?.();
 
       console.log(`\n\n\nStarting ${this._params.name}... `);
 
@@ -288,9 +306,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
         this._rootServices = await this.getRootServices();
       }
       
-      if (this.postProcess) { 
-        await this.postProcess();
-      }
+      await this.postProcess?.();
 
 
       if (!extended) {
@@ -300,7 +316,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           console.log(this.params.title);
           console.log(`Version: ${this.params.version}`);
         }
-        Dynamo_Log.testSuccess(`${this.params.name} started successfully.`);
+        Dynamo_Log.H_success(`${this.params.name} started successfully.`);
       }
     } catch (error) {
       this.constructErrors.push(error);
@@ -455,7 +471,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       }
 
       if (!dontLog) {
-        Dynamo_Log.test(`${this._params.name} stopped successfully.`);
+        Dynamo_Log.H_log(`${this._params.name} stopped successfully.`);
       }
     }
   }
@@ -885,6 +901,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
   /**
    * MISSING Description (TODO)
+   * only implemented for endpoints and global Unhandled Rejection
    */
-  getGlobalErrorHandler?(): (err: any, req: Request, res: Response, issuer: string) => Promise<void>;
+  getGlobalErrorHandler?(): (err: any, req?: Request, res?: Response, issuer?: string) => Promise<void>;
 }