Merge pull request #471 from ansforge/chore/improve-lrm-logs

chore(lrm): add message type in message logs metadata method

Author: SimonClo

web/lrm/server/src/logger.test.ts

@@ -11,25 +11,53 @@ describe('getMessageLogsMetadata', () => {
                     explicitAddressValue: 'recipient-789',
                 },
             },
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                createCaseHealth: {},
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        },
+                    },
+                },
+            ],
         };
         const meta = getMessageLogsMetadata(message);
         expect(meta).toEqual({
             distributionId: 'dist-123',
             senderId: 'sender-456',
             recipientId: 'recipient-789',
+            messageType: 'createCaseHealth',
         });
     });
 
     it('should return recipientId undefined if descriptor is missing', () => {
         const message = {
             distributionID: 'dist-1',
             senderID: 'sender-2',
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                createCaseHealth: {},
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        },
+                    },
+                },
+            ],
         };
         const meta = getMessageLogsMetadata(message);
         expect(meta).toEqual({
             distributionId: 'dist-1',
             senderId: 'sender-2',
             recipientId: undefined,
+            messageType: 'createCaseHealth',
         });
     });
 
@@ -38,12 +66,26 @@ describe('getMessageLogsMetadata', () => {
             distributionID: 'dist-X',
             senderID: 'sender-Y',
             descriptor: {},
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                createCaseHealth: {},
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        },
+                    },
+                },
+            ],
         };
         const meta = getMessageLogsMetadata(message);
         expect(meta).toEqual({
             distributionId: 'dist-X',
             senderId: 'sender-Y',
             recipientId: undefined,
+            messageType: 'createCaseHealth',
         });
     });
 
@@ -54,12 +96,26 @@ describe('getMessageLogsMetadata', () => {
             descriptor: {
                 explicitAddress: {},
             },
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                createCaseHealth: {},
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        },
+                    },
+                },
+            ],
         };
         const meta = getMessageLogsMetadata(message);
         expect(meta).toEqual({
             distributionId: 'dist-A',
             senderId: 'sender-B',
             recipientId: undefined,
+            messageType: 'createCaseHealth',
         });
     });
 
@@ -70,6 +126,7 @@ describe('getMessageLogsMetadata', () => {
             distributionId: undefined,
             senderId: undefined,
             recipientId: undefined,
+            messageType: undefined,
         });
     });
 
@@ -82,17 +139,85 @@ describe('getMessageLogsMetadata', () => {
                     explicitAddressValue: null,
                 },
             },
+            content: null,
         };
         const meta = getMessageLogsMetadata(message);
         expect(meta).toEqual({
             distributionId: null,
             senderId: null,
             recipientId: null,
+            messageType: undefined,
         });
     });
 
     it('should return empty object for undefined message', () => {
         const meta = getMessageLogsMetadata(undefined);
         expect(meta).toEqual({});
+    });
+
+    it('should return undefined messageType when multiple candidate keys', () => {
+        const message = {
+            distributionID: 'dist-123',
+            senderID: 'sender-456',
+            descriptor: {
+                explicitAddress: {
+                    explicitAddressValue: 'recipient-789',
+                },
+            },
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                createCaseHealth: {},
+                                createCaseHealthUpdate: {},
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        }
+                    }
+                }
+            ]
+        }
+
+        const metadata = getMessageLogsMetadata(message);
+        expect(metadata).toEqual({
+            distributionId: 'dist-123',
+            senderId: 'sender-456',
+            recipientId: 'recipient-789',
+            messageType: undefined,
+        });
+    })
+
+    it('should return undefined messageType when no candidate keys', () => {
+        const message = {
+            distributionID: 'dist-123',
+            senderID: 'sender-456',
+            descriptor: {
+                explicitAddress: {
+                    explicitAddressValue: 'recipient-789',
+                },
+            },
+            content: [
+                {
+                    jsonContent: {
+                        embeddedJsonContent: {
+                            message: {
+                                messageId: 'msg-001',
+                                sender: 'sender-456',
+                            }
+                        }
+                    }
+                }
+            ]
+        }
+
+        const metadata = getMessageLogsMetadata(message);
+        expect(metadata).toEqual({
+            distributionId: 'dist-123',
+            senderId: 'sender-456',
+            recipientId: 'recipient-789',
+            messageType: undefined,
+        });
     })
 });

web/lrm/server/src/logger.ts

@@ -19,16 +19,30 @@ type MessageLogsMetadata = {
     distributionId?: string
     senderId?: string
     recipientId?: string
+    messageType?: string
+}
+
+const getMessageType = (message: any): string | undefined => {
+    const messageContent = message?.content?.[0]?.jsonContent?.embeddedJsonContent?.message ?? {};
+    const excludedKeys = ["messageId", "sender", "sentAt", "kind", "status", "recipient"];
+    const candidateKeys = Object.keys(messageContent)
+        .filter(k => !excludedKeys.includes(k));
+
+    // Return the message type if there's exactly one candidate key, otherwise we can't determine it
+    return candidateKeys.length === 1 ? candidateKeys[0] : undefined;
+
 }
 
 export const getMessageLogsMetadata = (message: any): MessageLogsMetadata => {
     if (!message) return {};
     const distributionId = message.distributionID;
     const senderId = message.senderID;
     const recipientId = message.descriptor?.explicitAddress?.explicitAddressValue;
+    const messageType = getMessageType(message);
     return {
         distributionId,
         senderId,
         recipientId,
+        messageType,
     };
 }