@futdevpro/nts-dynamo 1.7.15 → 1.7.16

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

@@ -200,13 +200,21 @@ export class DynamoNTS_EndpointParams{
       msg += this.getPathParamsLogContent(req);
 
       Dynamo_Log.error(msg);
-      Dynamo_Log.log('ERROR:',
+      Dynamo_Log.error(
+        'ERROR:',
         (error as Dynamo_Error)?.flag?.includes('DYNAMO') ? 
           (error as Dynamo_Error).getErrorSimplified() : 
           error, 
         '\n'
       );
 
+      if ((error as Dynamo_Error)?.flag?.includes('DYNAMO')) {
+        if (!(error as Dynamo_Error).additionalContent) {
+          (error as Dynamo_Error).additionalContent = {};
+        }
+        (error as Dynamo_Error).additionalContent.endpointInfo = msg;
+      }
+
       await DynamoNTS_GlobalService.globalErrorHandler?.(error, req, res, issuer).catch(err => {
         Dynamo_Log.warn('DynamoNTS_GlobalService.globalErrorHandler failed to handle error: ', err);
         Dynamo_Log.warn('It will proceed as normal.');

package/src/_models/control-models/system-control.control-model.ts

@@ -3,7 +3,6 @@
 
 export class DynamoNTS_SystemControl {
   init: boolean = false;
-  /* failed: boolean = false; */
   started: boolean = false;
 
   getReady(): boolean {

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

@@ -63,7 +63,11 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
 
       this.instance.authService = set.authService;
       this.instance.emailServiceCollection = set.emailServiceCollection;
-      DynamoNTS_GlobalService.globalErrorHandler = set.errorHandler;
+      
+      DynamoNTS_GlobalService.globalErrorHandler = set.errorHandler ?? (async (error: any) => {
+        Dynamo_Log.warn(`globalErrorHandler not set!`);
+        Dynamo_Log.error(`ERROR:\n`, error)
+      });
     } catch (error) {
       Dynamo_Log.error(`Failed to create DynamoNTS_GlobalService.`, error);
       /* error = new Dynamo_Error({

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

@@ -222,6 +222,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   protected logSetup: boolean;
   protected deepLog: boolean;
   protected logFn: boolean;
+  protected debugLog: boolean;
 
   constructor(extended?: boolean){
     super();
@@ -525,38 +526,60 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    */
   private async startDB(): Promise<void> {
     if (this.logFn && this.deepLog) console.log('\nfn:. startDB');
+
     await new Promise<void>(
       async (resolve, reject) => {
         this.systemControls.mongoose.init = true;
+
         this.mongoose.connection
+          .once('open', () => {
+            this.systemControls.mongoose.started = true;
+            Dynamo_Log.success('\nConnected to MongoDB\n');
+
+            resolve();
+          })
           .on('error', (error) => {
-            this.systemControls.mongoose.started = false;
-            this.constructErrors.push(error);
-            Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
-            reject(
-              new Dynamo_Error({
+            if (!this.systemControls.mongoose.started) {
+              this.constructErrors.push(error);
+  
+              if (this.debugLog) Dynamo_Log.error('\nUnable to connect to MongoDB server, ERROR: ', error);
+
+              const d_error: Dynamo_Error = new Dynamo_Error({
                 ...this._getDefaultErrorSettings(
                   'startDB',
                   error
                 ),
-
+  
                 errorCode: 'NTS-AS0-SDB1',
-                message: `Unable to connect to MongoDB server, ERROR: ${error}`,
-              })
-            );
-          })
-          .once('open', () => {
-            this.systemControls.mongoose.started = true;
-            Dynamo_Log.success('\nConnected to MongoDB\n');
-            resolve();
+                message: `Unable to start connection to MongoDB server, ERROR: ${error}`,
+              });
+
+              DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+              reject(d_error);
+
+            } else {  
+              if (this.debugLog) Dynamo_Log.error('\nMongoDB ERROR: ', error);
+
+              const d_error: Dynamo_Error = new Dynamo_Error({
+                ...this._getDefaultErrorSettings(
+                  'mongoose.connection.on(error)',
+                  error
+                ),
+  
+                errorCode: 'NTS-AS0-SDB2',
+                message: `MongoDB ERROR: ${error}`,
+              });
+
+              DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+            }
           });
 
         this.mongoose.connect(
-            this._params.dbUri, 
-            {
-              useNewUrlParser: true,
-              useUnifiedTopology: true 
-            }
+          this._params.dbUri, 
+          {
+            useNewUrlParser: true,
+            useUnifiedTopology: true 
+          }
         );
       }
     );
@@ -567,6 +590,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
    */
   private async initExpresses(): Promise<void> {
     if (this.logFn && this.deepLog) console.log('\nfn:. initExpresses');
+
     if (this._security && this._security !== DynamoNTS_RouteSecurity.secure) {
       if (!this._portSettings.httpPort) {
         let errorMsg: string =
@@ -604,11 +628,12 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           `\nYou have secure routes, but the certification paths or httpsPort are not set!` +
           `\nsecurity: ${this._security}` +
           `\nset...` +
-          `\n  httpsPort and` +
+          `\n(missing exact howto...)` +
+          /* `\n  httpsPort and` +
           `\n  cert: {` +
           `\n    keyPath: FileSystem.PathLike,` +
           `\n    certPath: FileSystem.PathLike,` +
-          `\n  }` +
+          `\n  }` + */
           `\nin DynamoBEServer - getRoutingModules() to enable secure routes.`;        
 
         errorMsg += '\n\nThe routes setted to use secure server:';
@@ -675,37 +700,56 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             .listen(this._portSettings.httpsPort, 'localhost', 0, () => {
               this.systemControls.httpsServer.started = true;
               Dynamo_Log.success(`\nHTTPS (secure) server is listening on port: ${this._portSettings.httpsPort}`);
+
               resolve();
             })
             .on('error', (error) => {
-              this.systemControls.httpsServer.started = false;
-              this.constructErrors.push(error);
-              Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
-              reject(
-                new Dynamo_Error({
+              if (this.debugLog) Dynamo_Log.error(`\nHTTPS (secure) server ERROR`, error);
+              
+              if (!this.systemControls.httpsServer.started) {
+                const d_error: Dynamo_Error = new Dynamo_Error({
                   ...this._getDefaultErrorSettings(
                     'startExpresses',
                     error
                   ),
 
                   errorCode: 'NTS-AS0-SE1',
-                  message: `HTTPS (secure) server ERROR`,
-                })
-              );
-            })
-            .on('uncaughtException', (ex) => {
-              Dynamo_Log.warn(
-                `\nHTTPS (secure) server uncaughtException`,
-                new Dynamo_Error({
+                  message: `HTTPS (secure) start server ERROR`,
+                });
+
+                this.constructErrors.push(d_error);
+                DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+
+                reject(d_error);
+
+              } else {
+                const d_error: Dynamo_Error = new Dynamo_Error({
                   ...this._getDefaultErrorSettings(
-                    'startExpresses',
-                    ex
+                    'httpsServer.on(error)',
+                    error
                   ),
 
                   errorCode: 'NTS-AS0-SE2',
-                  message: `HTTPS (secure) server uncaughtException`,
-                })
-              );
+                  message: `HTTPS (secure) server ERROR`,
+                });
+
+                DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+              }
+            })
+            .on('uncaughtException', (ex) => {
+              const d_error: Dynamo_Error = new Dynamo_Error({
+                ...this._getDefaultErrorSettings(
+                  'httpsServer.on(uncaughtException)',
+                  ex
+                ),
+
+                errorCode: 'NTS-AS0-SE3',
+                message: `HTTPS (secure) server uncaughtException`,
+              });
+
+              if (this.debugLog) Dynamo_Log.warn(`\nHTTPS (secure) server uncaughtException`, d_error);
+
+              DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
             });
         });
       }
@@ -717,38 +761,56 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             .listen(this._portSettings.httpPort, () => {
               this.systemControls.httpServer.started = true;
               Dynamo_Log.success(`\nHTTP (open) server is listening on port: ${this._portSettings.httpPort}`);
+
               resolve();
             })
             .on('error', (error) => {
-              this.systemControls.httpServer.started = false;
-              this.constructErrors.push(error);
+              if (this.debugLog) Dynamo_Log.error(`\nHTTP (open) server ERROR`, error);
 
-              Dynamo_Log.error(`\nHTTP (open) server ERROR`, error);
-              reject(
-                new Dynamo_Error({
+              if (!this.systemControls.httpServer.started) {
+                const d_error: Dynamo_Error = new Dynamo_Error({
                   ...this._getDefaultErrorSettings(
                     'startExpresses',
                     error
                   ),
 
                   errorCode: 'NTS-AS0-SE3',
-                  message: `HTTP (open) server ERROR`,
-                })
-              );
-            })
-            .on('uncaughtException', (ex) => {
-              Dynamo_Log.warn(
-                `\nHTTP (open) server uncaughtException`,
-                new Dynamo_Error({ 
+                  message: `HTTP (open) start server ERROR`,
+                });
+                
+                this.constructErrors.push(d_error);
+                DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+
+                reject(d_error);
+
+              } else {
+                const d_error: Dynamo_Error = new Dynamo_Error({
                   ...this._getDefaultErrorSettings(
-                    'startExpresses',
-                    ex
+                    'httpServer.on(error)',
+                    error
                   ),
 
                   errorCode: 'NTS-AS0-SE4',
-                  message: `HTTP (open) server uncaughtException`, 
-                })
-              );
+                  message: `HTTP (open) server ERROR`,
+                });
+
+                DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
+              }
+            })
+            .on('uncaughtException', (ex) => {
+              const d_error: Dynamo_Error = new Dynamo_Error({
+                ...this._getDefaultErrorSettings(
+                  'httpServer.on(uncaughtException)',
+                  ex
+                ),
+
+                errorCode: 'NTS-AS0-SE5',
+                message: `HTTP (open) server uncaughtException`,
+              });
+
+              if (this.debugLog) Dynamo_Log.warn(`\nHTTP (open) server uncaughtException`, d_error);
+
+              DynamoNTS_GlobalService.globalErrorHandler?.(d_error);
             });
         });
       }
@@ -761,19 +823,29 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   /**
    * 
    */
-  private async expressErrorHandling(err, req, res, next): Promise<void> {
+  private async expressErrorHandling(error, req, res, next): Promise<void> {
     try {
-      if (err) {
-        if (DynamoNTS_GlobalService.globalErrorHandler) {
-          Dynamo_Log.error('unhandled express ERROR (must be a parsing error...)');
-          await DynamoNTS_GlobalService.globalErrorHandler?.(err, req, res);
-        } else {
-          Dynamo_Log.error('unhandled express ERROR (must be a parsing error...)', err);          
-        }
+      if (error) {
+        const d_error: Dynamo_Error = new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'expressErrorHandling',
+            error
+          ),
+
+          errorCode: 'NTS-AS0-EEH1',
+          message: `Express ERROR`,
+          additionalContent: {
+            req,
+            res,
+          },
+        });
+
+        await DynamoNTS_GlobalService.globalErrorHandler?.(d_error, req, res);
+
       } else {
         Dynamo_Log.H_error(
           'WTF??? express error; without error?...' + 
-          '\nerr:', err,
+          '\nerr:', error,
           '\nreq:', req,
           '\nres:', res
         );