@viplance/nestjs-logger 0.4.7 → 0.4.8

package/src/services/memory-db.service.ts

@@ -63,10 +63,99 @@ export class MemoryDbService {
     entity: EntitySchema,
     options?: {
       select?: string[];
+      where?: any;
+      order?: { [key: string]: 'ASC' | 'DESC' };
+      take?: number;
+      skip?: number;
     }
   ): Promise<any[]> {
     const table = this.getTableName(entity);
+    let data = [...this.db[table]];
+
+    // filter by search if where contains $or or Like (simplified for memory db)
+    // filter by search if where contains $or or Like (simplified for memory db)
+    if (options?.where) {
+      if (options.where.$or) {
+        const search = options.where.$or[0].message.$regex;
+        if (search) {
+          const regex = new RegExp(search, 'i');
+          data = data.filter(
+            (item) => regex.test(item.message) || regex.test(item.trace || '')
+          );
+        }
+      } else if (Array.isArray(options.where)) {
+        // handle Like constraints
+        const searchItem = options.where.find((w: any) => w.message);
+        if (searchItem && searchItem.message) {
+          let search = '';
+          if (typeof searchItem.message === 'string') {
+            search = searchItem.message.replace(/%/g, '');
+          } else if (searchItem.message.value) {
+            // FindOperator
+            search = searchItem.message.value.replace(/%/g, '');
+          } else if (searchItem.message._value) {
+            // FindOperator private
+            search = searchItem.message._value.replace(/%/g, '');
+          }
+
+          if (search) {
+            const regex = new RegExp(search, 'i');
+            data = data.filter(
+              (item) => regex.test(item.message) || regex.test(item.trace || '')
+            );
+          }
+        }
+      }
+
+      // Handle type filtering
+      let types: string[] | null = null;
+      let typeVal: any;
+
+      if (Array.isArray(options.where)) {
+        typeVal = options.where[0]?.type;
+      } else {
+        typeVal = options.where.type;
+      }
+
+      if (typeVal) {
+        if (Array.isArray(typeVal)) {
+          types = typeVal;
+        } else if (typeVal.value && Array.isArray(typeVal.value)) {
+          types = typeVal.value;
+        } else if (typeVal._value && Array.isArray(typeVal._value)) {
+          types = typeVal._value;
+        } else if (typeVal.$in && Array.isArray(typeVal.$in)) {
+          types = typeVal.$in;
+        }
+      }
+
+      if (types) {
+        data = data.filter((item) => types!.includes(item.type));
+      }
+    }
+
+    // sort
+    if (options?.order) {
+      const field = Object.keys(options.order)[0];
+      const direction = options.order[field];
+      data.sort((a, b) => {
+        if (a[field] < b[field]) return direction === 'ASC' ? -1 : 1;
+        if (a[field] > b[field]) return direction === 'ASC' ? 1 : -1;
+        return 0;
+      });
+    } else {
+      data.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+
+    // pagination
+    if (options?.skip !== undefined) {
+      data = data.slice(options.skip);
+    }
+    if (options?.take !== undefined) {
+      data = data.slice(0, options.take);
+    }
 
+    // mapping (select)
     let mapOptions = (obj: any) => obj; // return the object as is by default
 
     if (options?.select) {
@@ -81,9 +170,7 @@ export class MemoryDbService {
       };
     }
 
-    return Promise.resolve(
-      this.db[table].map(mapOptions).sort((a, b) => b.updatedAt - a.updatedAt)
-    );
+    return Promise.resolve(data.map(mapOptions));
   }
 
   public async getOneById(entity: EntitySchema, _id: string): Promise<any> {

package/src/services/ws.service.ts

@@ -6,14 +6,14 @@ import { Subject } from 'rxjs';
 @Injectable()
 export class WsService {
   public onMessage: Subject<any> = new Subject();
-  private ws: WebSocket | null = null;
-  private connected: boolean = false;
+  private clients: Set<any> = new Set();
   private connectionTimeout: number = 500;
   private options: LogModuleOptions['websocket'] = {
     port: 8080,
     host: 'localhost',
   };
   private key: string = '';
+  private wsServer: any | null = null;
 
   setupConnection(options: LogModuleOptions['websocket'], key = '') {
     this.options = {
@@ -23,11 +23,11 @@ export class WsService {
     this.key = key;
 
     // Set up Web Socket server
-    if (this.ws) {
+    if (this.wsServer) {
       return;
     }
 
-    const wsServer = new WebSocketServer({
+    this.wsServer = new WebSocketServer({
       retryCount: 1,
       reconnectInterval: 1,
       handshakeTimeout: this.connectionTimeout,
@@ -38,45 +38,44 @@ export class WsService {
       `Logs WebSocket server is listening on port ${this.options.port}`
     );
 
-    wsServer.on('error', this.handleError);
-    wsServer.on('open', () => this.handleOpenConnection());
-    wsServer.on('ping', () => this.ping(this.ws));
-    wsServer.on('close', () => this.closeConnection(this.ws));
-    wsServer.on('message', this.handleMessage);
-    wsServer.on('connection', (connection: WebSocket) => {
-      this.ws = connection;
-      connection.onmessage = this.handleMessage;
+    this.wsServer.on('error', this.handleError);
+    this.wsServer.on('listening', () => this.handleOpenConnection());
+    this.wsServer.on('close', () => {
+      console.log('WebSocket server closed.');
+      this.wsServer = null;
+    });
+
+    this.wsServer.on('connection', (connection: any) => {
+      this.clients.add(connection);
+
+      connection.on('message', (message: any) => this.handleMessage(message));
+
+      connection.on('close', () => {
+        this.clients.delete(connection);
+      });
+
+      connection.on('error', () => {
+        this.clients.delete(connection);
+      });
     });
   }
 
   sendMessage(message: any) {
-    this.ws?.send(JSON.stringify(message));
+    this.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify(message));
+      }
+    });
   }
 
   private handleError = () => {
     const serverUrl = this.getServerUrl();
     console.error(`Server ${serverUrl} is not available.`);
 
-    setTimeout(this.setupConnection, this.connectionTimeout);
-  };
-
-  private closeConnection = (connection: any) => {
-    clearTimeout(connection.pingTimeout);
-
-    if (this.connected) {
-      console.log('Connection has been closed by server.');
-      this.connected = false;
-      this.handleError();
-    }
-  };
-
-  private ping = (connection: any) => {
-    console.log('Ping remote server.');
-    clearTimeout(connection.pingTimeout);
+    // If server failed, reset instance so retry can happen
+    this.wsServer = null;
 
-    connection.pingTimeout = setTimeout(() => {
-      connection.terminate();
-    }, 30000 + this.connectionTimeout);
+    setTimeout(() => this.setupConnection(this.options, this.key), this.connectionTimeout);
   };
 
   private handleMessage = (message: any) => {
@@ -97,13 +96,11 @@ export class WsService {
   };
 
   private getServerUrl = (): string => {
-    return `${this.options?.secure ? 'wss' : 'ws'}://${this.options?.host}:${
-      this.options?.port
-    }`;
+    return `${this.options?.secure ? 'wss' : 'ws'}://${this.options?.host}:${this.options?.port
+      }`;
   };
 
   private handleOpenConnection = async () => {
-    this.connected = true;
     const serverUrl = this.getServerUrl();
     console.log(`${serverUrl} has been connected.`);
   };