Address review feedback

Author: aclark4life

django_mongodb_extensions/mql_panel/forms.py

@@ -172,21 +172,58 @@ def _execute_query(self, db, collection, collection_name, operation, args_list):
             raise ValueError(f"Unsupported read operation: {operation}")
         return self.convert_documents_to_table(result_docs)
 
+    def _flatten_single_key_dicts(self, obj):
+        if isinstance(obj, dict):
+            if len(obj) == 1:
+                only_value = next(iter(obj.values()))
+                return self._flatten_single_key_dicts(only_value)
+            return {
+                key_name: self._flatten_single_key_dicts(value_item)
+                for key_name, value_item in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [self._flatten_single_key_dicts(value_item) for value_item in obj]
+        return obj
+
     def _format_cell_value(self, value):
-        """Format a single cell value for HTML table display."""
-        if isinstance(value, (str, int, float, bool)):
-            return {"value": str(value), "is_json": False}
         serialized = json_util.dumps(value)
-        parsed = json.loads(serialized)
-        if isinstance(parsed, dict) and len(parsed) == 1:
-            key, val = next(iter(parsed.items()))
-            return {"value": str(val), "is_json": False}
-        if isinstance(parsed, dict) and len(parsed) > 1:
-            return {"value": json.dumps(parsed, indent=4), "is_json": True}
-        return {"value": serialized, "is_json": False}
+        parsed_json = json.loads(serialized)
+        flattened_value = self._flatten_single_key_dicts(parsed_json)
+        if isinstance(flattened_value, (str, int, float, bool)):
+            return {"value": str(flattened_value), "is_json": False}
+        if isinstance(flattened_value, dict):
+            return {
+                "type": "dict",
+                "value": self._format_dict_for_template(flattened_value),
+                "is_json": False,
+            }
+        if isinstance(flattened_value, list):
+            return {
+                "type": "list",
+                "value": self._format_list_for_template(flattened_value),
+                "is_json": False,
+            }
+        return {
+            "value": json.dumps(flattened_value, indent=4),
+            "is_json": True,
+        }
+
+    def _format_dict_for_template(self, dictionary):
+        return [
+            {"key": key_name, **self._format_cell_value(value_item)}
+            for key_name, value_item in dictionary.items()
+        ]
+
+    def _format_list_for_template(self, list_items):
+        return [
+            {"key": index, **self._format_cell_value(value_item)}
+            for index, value_item in enumerate(list_items)
+        ]
+
+    def _format_row(self, row_dict):
+        return [self._format_cell_value(cell_value) for cell_value in row_dict.values()]
 
     def convert_documents_to_table(self, documents):
-        """Convert MongoDB documents to a table of rows and headers."""
         if not documents:
             return [], []
         # Collect all unique field names

django_mongodb_extensions/templates/mql_panel/mql_query.html

@@ -13,6 +13,7 @@ <h3>{% translate "Query Results" %}</h3>
       <dt>{% translate "Database" %}</dt>
       <dd>{{ alias }}</dd>
     </dl>
+
     <h4>{% translate "Query Results" %}</h4>
     <table>
       <thead>
@@ -27,7 +28,54 @@ <h4>{% translate "Query Results" %}</h4>
           <tr>
             {% for column in row %}
               <td>
-                {% if column.is_json %}
+                {% if column.type == "dict" %}
+                  <table class="subtable">
+                    {% for sub in column.value %}
+                      <tr>
+                        <th>{{ sub.key }}</th>
+                        <td>
+                          {% if sub.type == "dict" %}
+                            <table class="subtable">
+                              {% for inner in sub.value %}
+                                <tr><th>{{ inner.key }}</th><td>{{ inner.value }}</td></tr>
+                              {% endfor %}
+                            </table>
+                          {% elif sub.type == "list" %}
+                            <ul>
+                              {% for inner in sub.value %}
+                                <li>{{ inner.value }}</li>
+                              {% endfor %}
+                            </ul>
+                          {% else %}
+                            {{ sub.value }}
+                          {% endif %}
+                        </td>
+                      </tr>
+                    {% endfor %}
+                  </table>
+                {% elif column.type == "list" %}
+                  <ul>
+                    {% for sub in column.value %}
+                      <li>
+                        {% if sub.type == "dict" %}
+                          <table class="subtable">
+                            {% for inner in sub.value %}
+                              <tr><th>{{ inner.key }}</th><td>{{ inner.value }}</td></tr>
+                            {% endfor %}
+                          </table>
+                        {% elif sub.type == "list" %}
+                          <ul>
+                            {% for inner in sub.value %}
+                              <li>{{ inner.value }}</li>
+                            {% endfor %}
+                          </ul>
+                        {% else %}
+                          {{ sub.value }}
+                        {% endif %}
+                      </li>
+                    {% endfor %}
+                  </ul>
+                {% elif column.is_json %}
                   <pre style="margin: 0; padding: 0; border: none; background: none; white-space: pre-wrap; word-wrap: break-word; font-family: inherit;">{{ column.value }}</pre>
                 {% else %}
                   {{ column.value }}

tests/mql_panel/test_forms.py

@@ -59,15 +59,15 @@ def test_objectid(self):
         oid = ObjectId()
         result = self.form._format_cell_value(oid)
         # ObjectIds serialize to {"$oid": "<id>"} which is single-key
-        self.assertFalse(result["is_json"])
+        self.assertIs(result["is_json"], False)
         self.assertEqual(result["value"], str(json.loads(json_util.dumps(oid))["$oid"]))
 
     def test_datetime(self):
         """Datetime values as they might appear in a MongoDB doc."""
         dt = datetime.datetime(2024, 1, 1, 12, 30)
         result = self.form._format_cell_value(dt)
         # Datetimes serialize to {"$date": timestamp_ms} which is single-key dict
-        self.assertFalse(result["is_json"])
+        self.assertIs(result["is_json"], False)
         self.assertEqual(result["value"], str(json.loads(json_util.dumps(dt))["$date"]))
 
     def test_embedded_document(self):
@@ -78,7 +78,7 @@ def test_embedded_document(self):
             "created": datetime.datetime(2024, 2, 1, 18, 0),
         }
         result = self.form._format_cell_value(embedded_doc)
-        self.assertTrue(result["is_json"])
+        self.assertIs(result["is_json"], False)
         parsed_back = json.loads(result["value"])
         # Datetime will still be JSON date dict
         self.assertEqual(parsed_back["name"], "Alice")
@@ -90,5 +90,7 @@ def test_list_field(self):
         arr = ["tag1", "tag2", ObjectId()]
         result = self.form._format_cell_value(arr)
         # Lists are not dicts, so is_json = False
-        self.assertFalse(result["is_json"])
-        self.assertEqual(result["value"], json_util.dumps(arr))
+        self.assertIs(result["is_json"], False)
+        self.assertEqual(
+            result["value"], '["tag1", "tag2", {"$oid": "69cc8219f859271f0a081538"}]'
+        )