Populate enum messages in nested lists/maps

src/app/proto-definition-selector/proto-definition.service.spec.ts

@@ -40,6 +40,7 @@ message Test {
 message ReferenceMessage {
   string test = 1; 
   Test.NestedMessage nested_message = 2;
+  EnumTest enum_test = 3;
 }
 
 enum EnumTest {
@@ -92,7 +93,7 @@ describe('TestService', () => {
     expect(mapMessage.valueConfiguration.type).toBe(MessageTypeEnum.String);
 
     const referenceMessage = converted.values[8].configuration as ObjectMessage;
-    expect(referenceMessage.messageDefinition.values.length).toBe(2);
+    expect(referenceMessage.messageDefinition.values.length).toBe(3);
     expect(referenceMessage.messageDefinition.name).toBe('ReferenceMessage');
     const nestedReferenceMessage = referenceMessage.messageDefinition.values[0];
     expect(nestedReferenceMessage.configuration.type).toBe(
@@ -136,7 +137,11 @@ describe('TestService', () => {
     );
     const objectListNestedMessage =
       objectListMessage.subConfiguration as ObjectMessage;
-    expect(objectListNestedMessage.messageDefinition.values.length).toBe(2);
+    expect(objectListNestedMessage.messageDefinition.values.length).toBe(3);
+
+    const enumTestMessage = objectListNestedMessage.messageDefinition.values[2]
+      .configuration as EnumMessage;
+    expect(enumTestMessage.type).toBe(MessageTypeEnum.Enum);
   });
 });
 

src/app/proto-definition-selector/proto-definition.service.ts

@@ -93,11 +93,11 @@ export class ProtoDefinitionService {
             configuration = listConfiguration.subConfiguration;
           }
         } else if (value.configuration.type === MessageTypeEnum.Map) {
-          const listConfiguration = value.configuration as MapMessage;
+          const mapConfiguration = value.configuration as MapMessage;
           if (
-            listConfiguration.valueConfiguration.type === MessageTypeEnum.Object
+            mapConfiguration.valueConfiguration.type === MessageTypeEnum.Object
           ) {
-            configuration = listConfiguration.valueConfiguration;
+            configuration = mapConfiguration.valueConfiguration;
           }
         }
         if (configuration) {
@@ -119,6 +119,26 @@ export class ProtoDefinitionService {
             value.configuration as ObjectMessage,
             enumMessages
           );
+        } else if (value.configuration.type === MessageTypeEnum.List) {
+          const listConfiguration = value.configuration as ListMessage;
+          if (
+            listConfiguration.subConfiguration.type === MessageTypeEnum.Object
+          ) {
+            listConfiguration.subConfiguration = this.populateEnumMessages(
+              listConfiguration.subConfiguration as ObjectMessage,
+              enumMessages
+            );
+          }
+        } else if (value.configuration.type === MessageTypeEnum.Map) {
+          const mapConfiguration = value.configuration as MapMessage;
+          if (
+            mapConfiguration.valueConfiguration.type === MessageTypeEnum.Object
+          ) {
+            mapConfiguration.valueConfiguration = this.populateEnumMessages(
+              mapConfiguration.valueConfiguration as ObjectMessage,
+              enumMessages
+            );
+          }
         }
       }
     }
@@ -159,17 +179,44 @@ export class ProtoDefinitionService {
       }
     }
     objectMessage.messageDefinition.values =
-      objectMessage.messageDefinition.values.map((obj) =>
+      objectMessage.messageDefinition.values.map((obj) => {
-        obj.configuration.type === MessageTypeEnum.Object
+        if (obj.configuration.type === MessageTypeEnum.Object) {
-          ? {
+          return {
+            ...obj,
+            configuration: this.populateEnumMessages(
+              obj.configuration as ObjectMessage,
+              enumMessages
+            ),
+          };
+        } else if (obj.configuration.type === MessageTypeEnum.List) {
+          const listConfiguration = obj.configuration as ListMessage;
+          if (
+            listConfiguration.subConfiguration.type === MessageTypeEnum.Object
+          ) {
+            return {
               ...obj,
-              configuration: this.populateEnumMessages(
+              subConfiguration: this.populateEnumMessages(
-                obj.configuration as ObjectMessage,
+                listConfiguration.subConfiguration as ObjectMessage,
                 enumMessages
               ),
-            }
+            };
-          : obj
+          }
-      );
+        } else if (obj.configuration.type === MessageTypeEnum.Map) {
+          const mapConfiguration = obj.configuration as MapMessage;
+          if (
+            mapConfiguration.valueConfiguration.type === MessageTypeEnum.Object
+          ) {
+            return {
+              ...obj,
+              valueConfiguration: this.populateEnumMessages(
+                mapConfiguration.valueConfiguration as ObjectMessage,
+                enumMessages
+              ),
+            };
+          }
+        }
+        return obj;
+      });
     return objectMessage;
   }
 

test.proto

@@ -20,6 +20,8 @@ message Test {
   
   message ReferenceMessage {
     string test = 1; 
+    Test.NestedMessage nested = 2;
+    EnumTest enum_test = 3;
   }
   
   enum EnumTest {