@futdevpro/fsm-dynamo 1.9.29 → 1.9.31

package/src/_collections/utils/log.util.ts

@@ -4,6 +4,11 @@ import { DyFM_LogStyle } from '../../_enums/log-style.enum';
 /* export class D_Log implements DyFM_Log {}; */
 export type DyFM_L = DyFM_Log;
 
+/**
+ * DyFM_Log is a class that provides a set of methods to log messages to the console.
+ * This class have methods to log messages with different styles and colors, 
+ * such as success, error, warn, info and highlighted for each of them.
+ */
 export class DyFM_Log {
 
   static setStyle(styles: DyFM_LogStyle[]): void {
@@ -12,6 +17,7 @@ export class DyFM_Log {
     styles.forEach((style: DyFM_LogStyle): void => {
       styleSets += style;
     });
+    
     console.log(styleSets);
   }
   static resetStyle(): void {
@@ -24,6 +30,7 @@ export class DyFM_Log {
     styles.forEach((style: DyFM_LogStyle): void => {
       result += style;
     });
+
     result += input;
 
     if (!dontReset) {
@@ -36,70 +43,60 @@ export class DyFM_Log {
   static success(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.log(
-        `${DyFM_LogStyle.green}${DyFM_LogStyle.bright}${message}`, 
+        `${DyFM_LogStyle.green}${message}`, 
         ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
-      console.log(
-        `${DyFM_LogStyle.green}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
-      );
+      console.log(`${DyFM_LogStyle.green}${message}${DyFM_LogStyle.reset}`);
     }
   }
   /** 
    * @deprecated use DyFM_Log.success instead
    */
-  static logSuccess(message: string, ...optionalParams: any[]): void {
-    this.success(message, ...optionalParams);
-  } 
+  static readonly logSuccess = this.success;
 
   static error(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.error(
-        `${DyFM_LogStyle.red}${DyFM_LogStyle.bright}${message}`,
+        `${DyFM_LogStyle.red}${message}`,
         ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
-      console.error(
-        `${DyFM_LogStyle.red}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
-      );
+      console.error(`${DyFM_LogStyle.red}${message}${DyFM_LogStyle.reset}`);
     }
   }
   /** 
    * @deprecated use DyFM_Log.error instead
    */
-  static logError(message: string, ...optionalParams: any[]): void {
-    this.error(message, ...optionalParams);
-  }
+  static readonly logError = this.error;
 
   static warn(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.warn(
-        `${DyFM_LogStyle.yellow}${DyFM_LogStyle.bright}${message}`, 
+        `${DyFM_LogStyle.yellow}${message}`, 
         ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
-      console.warn(
-        `${DyFM_LogStyle.yellow}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
-      );
+      console.warn(`${DyFM_LogStyle.yellow}${message}${DyFM_LogStyle.reset}`);
     }
   }
   /** 
    * @deprecated use DyFM_Log.warn instead
    */
-  static warning(message: string, ...optionalParams: any[]): void {
-    this.warn(message, ...optionalParams);
-  }
+  static readonly warning = this.warn;
   /** 
    * @deprecated use DyFM_Log.warn instead
    */
-  static logWarning(message: string, ...optionalParams: any[]): void {
-    this.warn(message, ...optionalParams);
-  }
+  static readonly logWarning = this.warn;
 
+  // ez azért nem egy sima "static readonly info = console.info;", 
+  // mert azon nincs rajta az első input típusa, ami csak string lehet
   static info(message: string, ...optionalParams: any[]): void {
     console.info(message, ...optionalParams);
   }
 
+  // ez azért nem egy sima "static readonly log = console.log;", 
+  // mert azon nincs rajta az első input típusa, ami csak string lehet
   static log(message: string, ...optionalParams: any[]): void {
     console.log(message, ...optionalParams);
   }

package/src/_collections/utils/math/math.util.ts

@@ -29,6 +29,22 @@ export class DyFM_Math {
     return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
   }
 
+  static numberWithShorters(x: number): string {
+    if (x < 1000) {
+      return x.toString();
+    } else if (x < 1000000) {
+      return (x / 1000).toFixed(1) + 'k';
+    } else if (x < 1000000000) {
+      return (x / 1000000).toFixed(2) + 'M';
+    } else {
+      return (x / 1000000000).toFixed(3) + 'B';
+    }
+  }
+
+  static numberWithShortersAndSpaces(x: number): string {
+    return this.numberWithShorters(x).replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+  }
+
   static floatingNumberWithSpaces(x: number): string {
     const parts: string[] = x.toString().split('.');
 

package/src/_enums/log-style.enum.ts

@@ -4,6 +4,7 @@
 export enum DyFM_LogStyle {
   reset = '\x1b[0m',
 
+  /** (bold) */
   bright = '\x1b[1m',
   dim = '\x1b[2m',
   underline = '\x1b[4m',

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

@@ -357,9 +357,9 @@ export class DyFM_Error extends DyFM_Metadata {
     DyFM_Log.H_error(
       title,
       '\n    ErrorCode:', this._errorCode, 
-      '\n    Message:', this._message.replaceAll('\n', '\n      '),
-      '\n    UserMessage:', this.__userMessage.replaceAll('\n', '\n      '),
-      '\n\n    Stack:', this.stack.replaceAll('\n', '\n  ')
+      '\n    Message:', this._message.replaceAll?.('\n', '\n      '),
+      '\n    UserMessage:', this.__userMessage.replaceAll?.('\n', '\n      '),
+      '\n\n    Stack:', this.stack.replaceAll?.('\n', '\n  ')
     );
   }
 }

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

@@ -0,0 +1,81 @@
+
+export interface DyFM_GlobalLog_Settings {
+  /**
+   * this setting will set which logs will be shown
+   */
+  highDetailedLogs?: boolean;
+
+  deep?: boolean;
+
+  /**
+   * this setting will enable debug logs for setting up the application
+   */
+  setup?: boolean;
+
+  /**
+   * this is an application wide default setting for route debug logs
+   */
+  request?: boolean;
+
+  /**
+   * this is an application wide default setting for route debug logs
+   */
+  requestsParams?: boolean;
+
+  /**
+   * this is an application wide default setting for route debug logs
+   */
+  requestsContent?: boolean;
+
+  /**
+   * this is an application wide default setting for route debug logs
+   */
+  responseContent?: boolean;
+  
+
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
+  socket_allEvents?: boolean;
+
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
+  socket_mainEvents?: boolean;
+
+  /**
+   * this is an application wide default setting for socket debug logs
+   */
+  socket_eventContent?: boolean;
+
+
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  api_events?: boolean;
+
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  api_requestContents?: boolean;
+
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  api_requestSettings?: boolean;
+
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  api_responseContents?: boolean;
+
+
+  /**
+   * this is an application wide default setting for detailed error logs
+   */
+  detailedErrors?: boolean;
+
+  server_debug?: boolean;
+
+  functions?: boolean;
+}

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

@@ -0,0 +1,22 @@
+
+import { DyFM_GlobalLog_Settings } from './global-log-settings.interface';
+
+/**
+ * 
+ * @param logRequestsContent only will log if the specific logRequest is also true
+ * 
+ * @param logEventContent only will log if the specific socket event is also set to log
+ * 
+ */
+export interface DyFM_Global_Settings {
+  /**
+   * this will be used as the main baseUrl for the application,
+   * this is not required, but we suggest to use at least a '/api' as base route
+   */
+  baseUrl: string;
+
+  /**
+   * this setting will set which logs will be shown
+   */
+  log_settings: DyFM_GlobalLog_Settings;
+}

package/src/_modules/custom-data/_models/cud.data-model.ts

@@ -19,8 +19,7 @@ export class DyFM_CustomData<T = any> extends DyFM_Metadata {
   }
 }
 
-// rename to? DyFM_customData_dataModelParams
-export const DyFM_customDataModel_params: DyFM_DataModel_Params = 
+export const DyFM_customData_dataParams: DyFM_DataModel_Params = 
   new DyFM_DataModel_Params({
     dataName: 'customData',
     properties: [

package/src/_modules/socket/_enums/sck-event-key.enum.ts

@@ -0,0 +1,18 @@
+
+export enum DyFM_SocketEvent_Key {
+  /** incoming connection */
+  connection = 'connection',
+  /** outgoing connection */
+  connect = 'connect',
+
+  subscribe = 'subscribe',
+  subscriptionSuccessful = 'subscriptionSuccessful',
+  unsubscribe = 'unsubscribe',
+  unsubscribeSuccessful = 'unsubscribeSuccessful',
+  disconnect = 'disconnection',
+  
+  ping = 'ping',
+  event = 'event',
+  error = 'error',
+}
+

package/src/_modules/socket/_models/sck-client-params.control-model.ts

@@ -22,4 +22,6 @@ export class DyFM_SocketClient_Params {
       this.reconnect = false;
     }
   }
-}
+}
+
+

package/src/_modules/socket/_models/sck-socket-event.control-model.ts

@@ -0,0 +1,151 @@
+
+import { DyFM_global_settings } from '../../../_collections/constants/global-settings.const';
+import { DyFM_Array } from '../../../_collections/utils/array.util';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+
+import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+
+export type DyFM_SocketEventPreprocessTask<T = any, R = any> = 
+  (content?: T, issuer?: string) => Promise<R>;
+export type DyFM_SocketEventTask<T> = (content?: T, issuer?: string) => Promise<void>;
+
+/**
+ * socket handling and clarification is under development
+ */
+export class DyFM_SocketEvent<T>{
+  socketName?: string;
+  eventKey: DyFM_SocketEvent_Key | string;
+  serviceName?: string;
+  
+  preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[];
+  tasks?: DyFM_SocketEventTask<T>[];
+
+  logEvent?: boolean;
+  logEventContent?: boolean;
+
+  constructor(
+    set: {
+      /**
+       * naming the socket will help to follow eveFM on service,
+       * if not set, the eventKey will be used
+       */
+      name?: string,
+      /**
+       * define socket event type such as; 
+       * connection, connect, disconnect, message, error, or anything else
+       */
+      eventKey: DyFM_SocketEvent_Key | string,
+      /**
+       * serviceName is the name of the service that will be used for logging
+       */
+      serviceName?: string,
+      /**
+       * preProcesses are the functions the service needs to run before the actual function,
+       * these can be used for authentications, or translating data
+       * 
+       * the last function in the array should return the content in the type(T) of the socket<T>
+       */
+      preProcesses?: DyFM_SocketEventPreprocessTask<any, any>[],
+      /**
+       * tasks are the functions the service needs to run
+       */
+      tasks?: DyFM_SocketEventTask<T>[],
+      /**
+       * logEvent will create a log for the event triggered
+       */
+      logEvent?: boolean,
+      /**
+       * logEventContent will create a log for the event triggered with the content
+       */
+      logEventContent?: boolean,
+    }
+  ) {
+    try {
+      this.socketName = set.name ?? set.eventKey;
+      this.eventKey = set.eventKey;
+      this.serviceName = set.serviceName ?? 'UnknownSocketService';
+
+      this.preProcesses = set.preProcesses ?? [];
+      this.tasks = set.tasks ?? [];
+
+      if (set.logEvent !== undefined) {
+        this.logEvent = set.logEvent;
+      } else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {
+        this.logEvent = false;
+      } else if (
+        ([ 
+          DyFM_SocketEvent_Key.connection, 
+          DyFM_SocketEvent_Key.connect,
+          DyFM_SocketEvent_Key.disconnect,
+        ] as string[]).includes(this.eventKey)
+      ) {
+        this.logEvent = DyFM_global_settings.log_settings.socket_allEvents || 
+          DyFM_global_settings.log_settings.socket_mainEvents;
+      } else {
+        this.logEvent = DyFM_global_settings.log_settings.socket_allEvents;
+      }
+      this.logEventContent = set.logEventContent ??
+        DyFM_global_settings.log_settings.socket_eventContent;
+    } catch (error) {
+      DyFM_Log.error(
+        `\nSocket Event params setup failed (${this.serviceName}): ${set.eventKey}`, 
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * 
+   * @returns 
+   */
+  private async getPreLog(content: T): Promise<void> {
+    try {
+      if (this.logEventContent && this.eventKey !== DyFM_SocketEvent_Key.connection) {
+        DyFM_Log.log(
+          `--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
+          \ncontent:`, content
+        );
+      } else {
+        DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey}...`);
+      }
+    } catch (error) {
+      DyFM_Log.error(`PreLog failed... (socket:  ${this.serviceName})`, error);
+    }
+  }
+
+  /**
+   * 
+   * @returns 
+   */
+  async executeEventTasks(content?: T, issuer?: string): Promise<void> {
+    try {        
+      if (this.logEvent || this.logEventContent) {
+        await this.getPreLog(content);
+      }
+
+      await DyFM_Array.asyncForEach(
+        this.preProcesses, 
+        async (preProcess: DyFM_SocketEventPreprocessTask<any, any>) => {
+          content = await preProcess(content);
+        }
+      );
+
+      await DyFM_Array.asyncForEach(this.tasks, async (task: DyFM_SocketEventTask<T>) => {
+        await task(content, issuer);
+      });
+    } catch (error) {
+      DyFM_Log.error(
+        `Socket Event tasks failed to execute on ${this.serviceName}.... (${this.eventKey})`, 
+        error, 
+        'content:', 
+        content
+      );
+    }
+  }
+}
+
+
+
+