From b4dbb770bcd429a09e6163ed00b45c5b39ca09c1 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 14:25:28 -0400
Subject: [PATCH 01/25] feat: ROOT-45: Filter by annotator prototype


From b0fcde414e00c3c4a16a8a60b8fa999bd2f30b48 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 14:25:42 -0400
Subject: [PATCH 02/25] model changes

---
 label_studio/data_manager/models.py      | 19 ++++++++++++++++-
 label_studio/data_manager/serializers.py | 27 ++++++++++++++++++++----
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index 35859d581af1..f1d81f43555a 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -86,7 +86,24 @@ class FilterGroup(models.Model):
 
 
 class Filter(models.Model):
-    index = models.IntegerField(_('index'), default=0, help_text='To keep filter order')
+    # Optional reference to a parent filter. We only allow **one** level of nesting.
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        related_name='children',
+        null=True,
+        blank=True,
+        help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
+    )
+
+    # `index` is now only meaningful for **root** filters (parent is NULL)
+    index = models.IntegerField(
+        _('index'),
+        null=True,
+        blank=True,
+        default=None,
+        help_text='Display order among root filters only',
+    )
     column = models.CharField(_('column'), max_length=1024, help_text='Field name')
     type = models.CharField(_('type'), max_length=1024, help_text='Field type')
     operator = models.CharField(_('operator'), max_length=1024, help_text='Filter operator')
diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index 82cb85af0d39..fad17b1244c7 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -121,6 +121,7 @@ def to_internal_value(self, data):
                             'operator': f.get('operator', ''),
                             'type': f.get('type', ''),
                             'value': f.get('value', {}),
+                            'parent': f.get('parent'),
                         }
                     )
 
@@ -137,13 +138,17 @@ def to_representation(self, instance):
             filters.pop('filters', [])
             filters.pop('id', None)
 
-            for f in instance.filter_group.filters.order_by('index'):
+            # Root filters first (ordered by index), followed by child filters (any order)
+            roots = instance.filter_group.filters.filter(parent__isnull=True).order_by('index')
+            children = instance.filter_group.filters.filter(parent__isnull=False)
+            for f in list(roots) + list(children):
                 filters['items'].append(
                     {
                         'filter': f.column,
                         'operator': f.operator,
                         'type': f.type,
                         'value': f.value,
+                        'parent': f.parent_id,
                     }
                 )
             result['data']['filters'] = filters
@@ -159,11 +164,25 @@ def to_representation(self, instance):
 
     @staticmethod
     def _create_filters(filter_group, filters_data):
-        filter_index = 0
+        """Create Filter objects inside the provided ``filter_group``.
+
+        * For **root** filters (``parent`` is ``None``) we enumerate the
+          ``index`` so that the UI can preserve left-to-right order.
+        * For **child** filters we leave ``index`` as ``None`` – they are not
+          shown in the top-level ordering bar.
+        """
+
+        next_index = 0
         for filter_data in filters_data:
-            filter_data['index'] = filter_index
+            is_root = filter_data.get('parent') in (None, '')
+
+            # Assign ordering index only to root filters
+            filter_data['index'] = next_index if is_root else None
+
+            if is_root:
+                next_index += 1
+
             filter_group.filters.add(Filter.objects.create(**filter_data))
-            filter_index += 1
 
     def create(self, validated_data):
         with transaction.atomic():

From e3ff6132e7e85638a672d5abb6f2f6f6d43d0709 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 14:28:07 -0400
Subject: [PATCH 03/25] migration

---
 .../0013_filter_parent_alter_filter_index.py  | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py

diff --git a/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
new file mode 100644
index 000000000000..8f6b9033a2bd
--- /dev/null
+++ b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
@@ -0,0 +1,37 @@
+# Generated by Django 5.1.10 on 2025-06-17 18:27
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("data_manager", "0012_alter_view_user"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="filter",
+            name="parent",
+            field=models.ForeignKey(
+                blank=True,
+                help_text="Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)",
+                null=True,
+                on_delete=django.db.models.deletion.CASCADE,
+                related_name="children",
+                to="data_manager.filter",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="filter",
+            name="index",
+            field=models.IntegerField(
+                blank=True,
+                default=None,
+                help_text="Display order among root filters only",
+                null=True,
+                verbose_name="index",
+            ),
+        ),
+    ]

From 21be28fee861bbd95ca593ff3750e79e85fe3cff Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 14:42:51 -0400
Subject: [PATCH 04/25] update migration

---
 ..._alter_filter_index.py => 0013_filter_parent.py} | 13 +------------
 label_studio/data_manager/models.py                 | 10 ++--------
 label_studio/data_manager/serializers.py            |  8 +++++---
 3 files changed, 8 insertions(+), 23 deletions(-)
 rename label_studio/data_manager/migrations/{0013_filter_parent_alter_filter_index.py => 0013_filter_parent.py} (63%)

diff --git a/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py b/label_studio/data_manager/migrations/0013_filter_parent.py
similarity index 63%
rename from label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
rename to label_studio/data_manager/migrations/0013_filter_parent.py
index 8f6b9033a2bd..2173334754d3 100644
--- a/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
+++ b/label_studio/data_manager/migrations/0013_filter_parent.py
@@ -1,4 +1,4 @@
-# Generated by Django 5.1.10 on 2025-06-17 18:27
+# Generated by Django 5.1.10 on 2025-06-17 18:42
 
 import django.db.models.deletion
 from django.db import migrations, models
@@ -23,15 +23,4 @@ class Migration(migrations.Migration):
                 to="data_manager.filter",
             ),
         ),
-        migrations.AlterField(
-            model_name="filter",
-            name="index",
-            field=models.IntegerField(
-                blank=True,
-                default=None,
-                help_text="Display order among root filters only",
-                null=True,
-                verbose_name="index",
-            ),
-        ),
     ]
diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index f1d81f43555a..eaa58670d47c 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -96,14 +96,8 @@ class Filter(models.Model):
         help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
     )
 
-    # `index` is now only meaningful for **root** filters (parent is NULL)
-    index = models.IntegerField(
-        _('index'),
-        null=True,
-        blank=True,
-        default=None,
-        help_text='Display order among root filters only',
-    )
+    # Order of the filter inside its group. Not used for child filters.
+    index = models.IntegerField(_('index'), default=0, help_text='To keep filter order')
     column = models.CharField(_('column'), max_length=1024, help_text='Field name')
     type = models.CharField(_('type'), max_length=1024, help_text='Field type')
     operator = models.CharField(_('operator'), max_length=1024, help_text='Filter operator')
diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index fad17b1244c7..2f807c4ec9b9 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -176,11 +176,13 @@ def _create_filters(filter_group, filters_data):
         for filter_data in filters_data:
             is_root = filter_data.get('parent') in (None, '')
 
-            # Assign ordering index only to root filters
-            filter_data['index'] = next_index if is_root else None
-
             if is_root:
+                # Assign ordering index
+                filter_data['index'] = next_index
                 next_index += 1
+            else:
+                # For children we don't specify index, it'll default to 0
+                filter_data.pop('index', None)
 
             filter_group.filters.add(Filter.objects.create(**filter_data))
 

From 57e79b4fffcf583f9bdbc199a9a19f738e25040d Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 15:29:44 -0400
Subject: [PATCH 05/25] Revert "update migration"

This reverts commit 21be28fee861bbd95ca593ff3750e79e85fe3cff.
---
 ....py => 0013_filter_parent_alter_filter_index.py} | 13 ++++++++++++-
 label_studio/data_manager/models.py                 | 10 ++++++++--
 label_studio/data_manager/serializers.py            |  8 +++-----
 3 files changed, 23 insertions(+), 8 deletions(-)
 rename label_studio/data_manager/migrations/{0013_filter_parent.py => 0013_filter_parent_alter_filter_index.py} (63%)

diff --git a/label_studio/data_manager/migrations/0013_filter_parent.py b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
similarity index 63%
rename from label_studio/data_manager/migrations/0013_filter_parent.py
rename to label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
index 2173334754d3..8f6b9033a2bd 100644
--- a/label_studio/data_manager/migrations/0013_filter_parent.py
+++ b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
@@ -1,4 +1,4 @@
-# Generated by Django 5.1.10 on 2025-06-17 18:42
+# Generated by Django 5.1.10 on 2025-06-17 18:27
 
 import django.db.models.deletion
 from django.db import migrations, models
@@ -23,4 +23,15 @@ class Migration(migrations.Migration):
                 to="data_manager.filter",
             ),
         ),
+        migrations.AlterField(
+            model_name="filter",
+            name="index",
+            field=models.IntegerField(
+                blank=True,
+                default=None,
+                help_text="Display order among root filters only",
+                null=True,
+                verbose_name="index",
+            ),
+        ),
     ]
diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index eaa58670d47c..f1d81f43555a 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -96,8 +96,14 @@ class Filter(models.Model):
         help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
     )
 
-    # Order of the filter inside its group. Not used for child filters.
-    index = models.IntegerField(_('index'), default=0, help_text='To keep filter order')
+    # `index` is now only meaningful for **root** filters (parent is NULL)
+    index = models.IntegerField(
+        _('index'),
+        null=True,
+        blank=True,
+        default=None,
+        help_text='Display order among root filters only',
+    )
     column = models.CharField(_('column'), max_length=1024, help_text='Field name')
     type = models.CharField(_('type'), max_length=1024, help_text='Field type')
     operator = models.CharField(_('operator'), max_length=1024, help_text='Filter operator')
diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index 2f807c4ec9b9..fad17b1244c7 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -176,13 +176,11 @@ def _create_filters(filter_group, filters_data):
         for filter_data in filters_data:
             is_root = filter_data.get('parent') in (None, '')
 
+            # Assign ordering index only to root filters
+            filter_data['index'] = next_index if is_root else None
+
             if is_root:
-                # Assign ordering index
-                filter_data['index'] = next_index
                 next_index += 1
-            else:
-                # For children we don't specify index, it'll default to 0
-                filter_data.pop('index', None)
 
             filter_group.filters.add(Filter.objects.create(**filter_data))
 

From ae7a9a7c321fa40ea8fe6a772e755fe0a687473e Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 15:43:22 -0400
Subject: [PATCH 06/25] async migration

---
 .../0013_filter_parent_alter_filter_index.py  |  1 +
 .../migrations/0014_add_filter_parent_idx.py  | 78 +++++++++++++++++++
 label_studio/data_manager/models.py           |  1 +
 3 files changed, 80 insertions(+)
 create mode 100644 label_studio/data_manager/migrations/0014_add_filter_parent_idx.py

diff --git a/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
index 8f6b9033a2bd..98beef65282a 100644
--- a/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
+++ b/label_studio/data_manager/migrations/0013_filter_parent_alter_filter_index.py
@@ -21,6 +21,7 @@ class Migration(migrations.Migration):
                 on_delete=django.db.models.deletion.CASCADE,
                 related_name="children",
                 to="data_manager.filter",
+                db_index=False,
             ),
         ),
         migrations.AlterField(
diff --git a/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py b/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py
new file mode 100644
index 000000000000..d68e3370de16
--- /dev/null
+++ b/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py
@@ -0,0 +1,78 @@
+from django.db import migrations, connection
+from core.redis import start_job_async_or_sync
+from core.models import AsyncMigrationStatus
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+migration_name = "0014_add_filter_parent_idx"
+
+
+# Actual DDL executed asynchronously
+def forward_migration(migration_name):
+    migration = AsyncMigrationStatus.objects.create(
+        name=migration_name,
+        status=AsyncMigrationStatus.STATUS_STARTED,
+    )
+    logger.debug(f"Start async migration {migration_name}")
+
+    if connection.vendor == "postgresql":
+        sql = """
+        CREATE INDEX CONCURRENTLY IF NOT EXISTS "filter_parent_idx" 
+        ON "data_manager_filter" ("parent_id");
+        """
+    else:
+        # SQLite / others – use regular index (no CONCURRENTLY support)
+        sql = """
+        CREATE INDEX IF NOT EXISTS "filter_parent_idx" 
+        ON "data_manager_filter" ("parent_id");
+        """
+
+    with connection.cursor() as cursor:
+        cursor.execute(sql)
+
+    migration.status = AsyncMigrationStatus.STATUS_FINISHED
+    migration.save()
+    logger.debug(f"Async migration {migration_name} complete")
+
+
+def reverse_migration(migration_name):
+    migration = AsyncMigrationStatus.objects.create(
+        name=migration_name,
+        status=AsyncMigrationStatus.STATUS_STARTED,
+    )
+    logger.debug(f"Start async migration rollback {migration_name}")
+
+    if connection.vendor == "postgresql":
+        sql = "DROP INDEX CONCURRENTLY IF EXISTS \"filter_parent_idx\";"
+    else:
+        sql = "DROP INDEX IF EXISTS \"filter_parent_idx\";"
+
+    with connection.cursor() as cursor:
+        cursor.execute(sql)
+
+    migration.status = AsyncMigrationStatus.STATUS_FINISHED
+    migration.save()
+    logger.debug(f"Async migration rollback {migration_name} complete")
+
+
+def forwards(apps, schema_editor):
+    start_job_async_or_sync(forward_migration, migration_name=migration_name)
+
+
+def backwards(apps, schema_editor):
+    start_job_async_or_sync(reverse_migration, migration_name=migration_name)
+
+
+class Migration(migrations.Migration):
+    # Must be non-atomic so concurrent index creation isn't wrapped in a transaction
+    atomic = False
+
+    dependencies = [
+        ("data_manager", "0013_filter_parent_alter_filter_index"),
+    ]
+
+    operations = [
+        migrations.RunPython(forwards, backwards),
+    ] 
\ No newline at end of file
diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index f1d81f43555a..9749b5356355 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -93,6 +93,7 @@ class Filter(models.Model):
         related_name='children',
         null=True,
         blank=True,
+        db_index=False,  # added in a separate migration
         help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
     )
 

From 035677f4d53030234b4494aaa4f1244b104e2865 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 16:00:25 -0400
Subject: [PATCH 07/25] give up on index

---
 .../migrations/0014_add_filter_parent_idx.py  | 78 -------------------
 label_studio/data_manager/models.py           |  2 +-
 2 files changed, 1 insertion(+), 79 deletions(-)
 delete mode 100644 label_studio/data_manager/migrations/0014_add_filter_parent_idx.py

diff --git a/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py b/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py
deleted file mode 100644
index d68e3370de16..000000000000
--- a/label_studio/data_manager/migrations/0014_add_filter_parent_idx.py
+++ /dev/null
@@ -1,78 +0,0 @@
-from django.db import migrations, connection
-from core.redis import start_job_async_or_sync
-from core.models import AsyncMigrationStatus
-import logging
-
-
-logger = logging.getLogger(__name__)
-
-migration_name = "0014_add_filter_parent_idx"
-
-
-# Actual DDL executed asynchronously
-def forward_migration(migration_name):
-    migration = AsyncMigrationStatus.objects.create(
-        name=migration_name,
-        status=AsyncMigrationStatus.STATUS_STARTED,
-    )
-    logger.debug(f"Start async migration {migration_name}")
-
-    if connection.vendor == "postgresql":
-        sql = """
-        CREATE INDEX CONCURRENTLY IF NOT EXISTS "filter_parent_idx" 
-        ON "data_manager_filter" ("parent_id");
-        """
-    else:
-        # SQLite / others – use regular index (no CONCURRENTLY support)
-        sql = """
-        CREATE INDEX IF NOT EXISTS "filter_parent_idx" 
-        ON "data_manager_filter" ("parent_id");
-        """
-
-    with connection.cursor() as cursor:
-        cursor.execute(sql)
-
-    migration.status = AsyncMigrationStatus.STATUS_FINISHED
-    migration.save()
-    logger.debug(f"Async migration {migration_name} complete")
-
-
-def reverse_migration(migration_name):
-    migration = AsyncMigrationStatus.objects.create(
-        name=migration_name,
-        status=AsyncMigrationStatus.STATUS_STARTED,
-    )
-    logger.debug(f"Start async migration rollback {migration_name}")
-
-    if connection.vendor == "postgresql":
-        sql = "DROP INDEX CONCURRENTLY IF EXISTS \"filter_parent_idx\";"
-    else:
-        sql = "DROP INDEX IF EXISTS \"filter_parent_idx\";"
-
-    with connection.cursor() as cursor:
-        cursor.execute(sql)
-
-    migration.status = AsyncMigrationStatus.STATUS_FINISHED
-    migration.save()
-    logger.debug(f"Async migration rollback {migration_name} complete")
-
-
-def forwards(apps, schema_editor):
-    start_job_async_or_sync(forward_migration, migration_name=migration_name)
-
-
-def backwards(apps, schema_editor):
-    start_job_async_or_sync(reverse_migration, migration_name=migration_name)
-
-
-class Migration(migrations.Migration):
-    # Must be non-atomic so concurrent index creation isn't wrapped in a transaction
-    atomic = False
-
-    dependencies = [
-        ("data_manager", "0013_filter_parent_alter_filter_index"),
-    ]
-
-    operations = [
-        migrations.RunPython(forwards, backwards),
-    ] 
\ No newline at end of file
diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index 9749b5356355..234bc106ab90 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -93,7 +93,7 @@ class Filter(models.Model):
         related_name='children',
         null=True,
         blank=True,
-        db_index=False,  # added in a separate migration
+        db_index=False,
         help_text='Optional parent filter to create one-level hierarchy (child filters are AND-merged with parent)',
     )
 

From ba8e2f7cd1e906b415a1c1f8c54a5aa90e4ce40c Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Tue, 17 Jun 2025 16:08:40 -0400
Subject: [PATCH 08/25] omit parent when appropriate

---
 label_studio/data_manager/serializers.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index fad17b1244c7..5db290fe98ce 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -142,15 +142,15 @@ def to_representation(self, instance):
             roots = instance.filter_group.filters.filter(parent__isnull=True).order_by('index')
             children = instance.filter_group.filters.filter(parent__isnull=False)
             for f in list(roots) + list(children):
-                filters['items'].append(
-                    {
-                        'filter': f.column,
-                        'operator': f.operator,
-                        'type': f.type,
-                        'value': f.value,
-                        'parent': f.parent_id,
-                    }
-                )
+                item = {
+                    'filter': f.column,
+                    'operator': f.operator,
+                    'type': f.type,
+                    'value': f.value,
+                }
+                if f.parent_id:
+                    item['parent'] = f.parent_id
+                filters['items'].append(item)
             result['data']['filters'] = filters
 
         selected_items = result.pop('selected_items', {})

From 8abe888f3bfb5b279725c76466557f5e3d6cc6dd Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 07:13:13 -0400
Subject: [PATCH 09/25] wip FE for child filters

---
 .../Filters/FilterLine/FilterLine.jsx         | 20 +++++
 web/libs/datamanager/src/stores/Tabs/tab.js   | 74 +++++++++++++++++--
 .../src/stores/Tabs/tab_column.jsx            |  2 +
 .../datamanager/src/stores/Tabs/tab_filter.js | 21 ++++++
 4 files changed, 111 insertions(+), 6 deletions(-)

diff --git a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
index 374dfe3dc99e..d0425ae54b30 100644
--- a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
+++ b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
@@ -72,6 +72,26 @@ export const FilterLine = observer(({ filter, availableFilters, index, view, sid
       </GroupWrapper>
       <GroupWrapper wrap={sidebar}>
         <FilterOperation filter={filter} value={filter.currentValue} operator={filter.operator} field={filter.field} />
+
+        {/* Render child filters (join filters) inline */}
+        {filter.view.filters
+          .filter((f) => (f.parent && f.parent === filter.id) || f.localParent === filter)
+          .map((child, idx) => {
+            console.debug("[DM] render child filter", { parent: filter, child });
+            return (
+              <Elem name="column" key={`child-${idx}`} mix="value">
+                <Tag size="small" className="filters-data-tag" color="#1d91e4" style={{ marginRight: 4 }}>
+                  {child.field.title}
+                </Tag>
+                <FilterOperation
+                  filter={child}
+                  value={child.currentValue}
+                  operator={child.operator}
+                  field={child.field}
+                />
+              </Elem>
+            );
+          })}
       </GroupWrapper>
       <Elem name="remove">
         <Button
diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 8e1d4862b836..6e595b3f8cf0 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -113,7 +113,9 @@ export const Tab = types
       if (isFF(FF_ANNOTATION_RESULTS_FILTERING)) {
         return self.filters.filter((f) => f.target === self.target);
       }
-      return self.filters.filter((f) => f.target === self.target && !f.field.isAnnotationResultsFilterColumn);
+      return self.filters.filter(
+        (f) => f.target === self.target && !f.field.isAnnotationResultsFilterColumn && !f.parent && !f.localParent,
+      );
     },
 
     get currentOrder() {
@@ -370,7 +372,6 @@ export const Tab = types
       const filterType = self.availableFilters[0];
       const filter = TabFilter.create({
         filter: filterType,
-        view: self.id,
       });
 
       self.filters.push(filter);
@@ -378,6 +379,26 @@ export const Tab = types
       if (filter.isValidFilter) self.save();
     },
 
+    /**
+     * Create a new filter row for the provided filter *type* (column).
+     * Used internally to materialize join filters.
+     */
+    createChildFilterForType(filterType, parentFilter) {
+      const filter = TabFilter.create({
+        filter: filterType.id ?? filterType,
+        parent: null,
+      });
+
+      // keep local link until we know the backend id
+      filter.setLocalParent(parentFilter);
+
+      self.filters.push(filter);
+
+      console.debug("[DM] child filter instantiated", { parentFilter, child: filter });
+
+      return filter;
+    },
+
     toggleColumn(column) {
       if (self.hiddenColumns.hasColumn(column)) {
         self.hiddenColumns.remove(column);
@@ -399,11 +420,19 @@ export const Tab = types
     }),
 
     deleteFilter(filter) {
-      const index = self.filters.findIndex((f) => f === filter);
+      // Recursively delete child filters first
+      const childFilters = self.filters.filter((f) => (f.parent && f.parent === filter.id) || f.localParent === filter);
 
-      self.filters.splice(index, 1);
-      destroy(filter);
-      self.save();
+      childFilters.forEach((child) => {
+        self.deleteFilter(child);
+      });
+
+      const index = self.filters.findIndex((f) => f === filter);
+      if (index > -1) {
+        self.filters.splice(index, 1);
+        destroy(filter);
+        self.save();
+      }
     },
 
     afterAttach() {
@@ -452,6 +481,39 @@ export const Tab = types
     markSaved() {
       self.saved = true;
     },
+
+    /**
+     * Create child filters for a given root filter according to its column's `join_filters` metadata.
+     */
+    applyJoinFilters(rootFilter) {
+      const column = rootFilter.filter.field;
+      const joinFilters = column?.join_filters ?? [];
+
+      if (!Array.isArray(joinFilters) || joinFilters.length === 0) return;
+
+      // NOTE: using targetColumns instead of columns means that annotation results columns cannot be used in join_filters, but seems fine for now
+      self.targetColumns
+        .filter((c) => joinFilters.includes(c.alias))
+        .forEach((col) => {
+          const exists = self.filters.find(
+            (f) => (f.parent === rootFilter.id || f.localParent === rootFilter) && f.filter.field.id === col.id,
+          );
+
+          console.debug("[DM] join-filter check", { col: col.id, exists });
+
+          if (!exists) {
+            const filterType = self.availableFilters.find((ft) => ft.field.id === col.id);
+
+            if (filterType) {
+              const childFilter = self.createChildFilterForType(filterType, rootFilter);
+
+              childFilter.setOperator(rootFilter.operator);
+
+              console.debug("[DM] join-filter created", { parent: rootFilter.id, child: childFilter });
+            }
+          }
+        });
+    },
   }))
   .preProcessSnapshot((snapshot) => {
     if (snapshot === null) return snapshot;
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_column.jsx b/web/libs/datamanager/src/stores/Tabs/tab_column.jsx
index b4c99a9700e9..07a047fcd703 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_column.jsx
+++ b/web/libs/datamanager/src/stores/Tabs/tab_column.jsx
@@ -75,6 +75,8 @@ export const TabColumn = types
     target: types.enumeration(["tasks", "annotations"]),
     orderable: types.optional(types.boolean, true),
     help: types.maybeNull(types.string),
+    // List of column aliases whose filters should be joined automatically when a filter is created for this column
+    join_filters: types.maybeNull(types.array(types.string)),
   })
   .views((self) => ({
     get hidden() {
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_filter.js b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
index ac7cebd4a150..ba4ee1decad0 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_filter.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
@@ -21,9 +21,20 @@ const getOperatorDefaultValue = (operator) => {
 
 export const TabFilter = types
   .model("TabFilter", {
+    /**
+     * Backend primary key. Undefined until the filter is saved and the API returns it.
+     */
+    id: types.maybeNull(types.number),
+
     filter: types.reference(TabFilterType),
     operator: types.maybeNull(Operators),
     value: types.maybeNull(FilterValueType),
+
+    /**
+     * Backend id of the parent filter (root filter). For child filters only.
+     * For yet-unsaved children this is null until the parent receives its backend id.
+     */
+    parent: types.maybeNull(types.number),
   })
   .views((self) => ({
     get field() {
@@ -92,6 +103,9 @@ export const TabFilter = types
     wasValid: false,
     saved: false,
     saving: false,
+
+    /** Temporary link to the parent TabFilter instance while the backend id is unknown */
+    localParent: null,
   }))
   .actions((self) => ({
     afterAttach() {
@@ -121,6 +135,9 @@ export const TabFilter = types
       if (typeChanged) {
         self.setDefaultValue();
         self.setOperator(self.component[0].key);
+
+        // Spawn child filters (join_filters) via view action to stay within MST action boundaries
+        self.view.applyJoinFilters(self);
       }
 
       if (filterChanged) {
@@ -198,6 +215,10 @@ export const TabFilter = types
     saveDelayed: debounce(() => {
       self.save();
     }, 300),
+
+    setLocalParent(parent) {
+      self.localParent = parent;
+    },
   }))
   .preProcessSnapshot((sn) => {
     return { ...sn, value: sn.value ?? null };

From 91331c0eafd192f041437c995d7c28a5c29cda83 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 09:12:33 -0400
Subject: [PATCH 10/25] allow parent index instead of parent id

---
 label_studio/data_manager/serializers.py | 57 +++++++++++++++++++++---
 1 file changed, 51 insertions(+), 6 deletions(-)

diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index 5db290fe98ce..b796a3e44cdf 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -22,6 +22,14 @@
 
 
 class FilterSerializer(serializers.ModelSerializer):
+    # Allow children filters to reference parent by root-filter index instead of DB id
+    parent_index = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        write_only=True,
+        help_text='Index of the parent filter inside the same FilterGroup (alternative to `parent` PK)',
+    )
+
     class Meta:
         model = Filter
         fields = '__all__'
@@ -122,6 +130,7 @@ def to_internal_value(self, data):
                             'type': f.get('type', ''),
                             'value': f.get('value', {}),
                             'parent': f.get('parent'),
+                            'parent_index': f.get('parent_index'),
                         }
                     )
 
@@ -172,17 +181,53 @@ def _create_filters(filter_group, filters_data):
           shown in the top-level ordering bar.
         """
 
+        # Pass 1 — create root filters (no parent/parent_index) and build index→object map
+        index_to_filter = {}
         next_index = 0
         for filter_data in filters_data:
-            is_root = filter_data.get('parent') in (None, '')
+            is_root = filter_data.get('parent') in (None, '') and filter_data.get('parent_index') in (None, '')
+
+            if not is_root:
+                continue
+
+            # Enumerate root filters for stable ordering
+            filter_data['index'] = next_index
+            next_index += 1
 
-            # Assign ordering index only to root filters
-            filter_data['index'] = next_index if is_root else None
+            # Remove helper key before model instantiation
+            filter_data.pop('parent_index', None)
+
+            root_obj = Filter.objects.create(**filter_data)
+            filter_group.filters.add(root_obj)
+            index_to_filter[root_obj.index] = root_obj
+
+        # Pass 2 — create child filters, resolving parent via `parent` PK or `parent_index`
+        for filter_data in filters_data:
+            has_parent_pk = filter_data.get('parent') not in (None, '')
+            has_parent_index = filter_data.get('parent_index') not in (None, '')
+
+            if not (has_parent_pk or has_parent_index):
+                # Already processed as a root filter
+                continue
+
+            fixed_data = filter_data.copy()
+
+            if has_parent_pk:
+                parent_obj = filter_group.filters.get(id=fixed_data['parent'])
+            else:
+                parent_idx = fixed_data.get('parent_index')
+                parent_obj = index_to_filter.get(parent_idx)
+                if parent_obj is None:
+                    raise serializers.ValidationError(
+                        f'parent_index={parent_idx} does not correspond to any root filter',
+                    )
 
-            if is_root:
-                next_index += 1
+            fixed_data['parent'] = parent_obj
+            fixed_data['index'] = None  # Child filters do not participate in top-level ordering
+            fixed_data.pop('parent_index', None)
 
-            filter_group.filters.add(Filter.objects.create(**filter_data))
+            child_obj = Filter.objects.create(**fixed_data)
+            filter_group.filters.add(child_obj)
 
     def create(self, validated_data):
         with transaction.atomic():

From 2b47439e5b61502113b35cdf48bb7ed6ff5c6bcf Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 09:20:59 -0400
Subject: [PATCH 11/25] use parent_index

---
 .../Filters/FilterLine/FilterLine.jsx         | 36 +++++++++----------
 web/libs/datamanager/src/stores/Tabs/tab.js   | 21 ++++++-----
 .../datamanager/src/stores/Tabs/tab_filter.js | 12 ++-----
 3 files changed, 33 insertions(+), 36 deletions(-)

diff --git a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
index d0425ae54b30..0f426be16e5e 100644
--- a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
+++ b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
@@ -31,6 +31,8 @@ const GroupWrapper = ({ children, wrap = false }) => {
 };
 
 export const FilterLine = observer(({ filter, availableFilters, index, view, sidebar, dropdownClassName }) => {
+  const childFilters = filter.view.filters.filter((f) => f.parent_index === index);
+
   return (
     <Block name="filter-line" tag={Fragment}>
       <GroupWrapper wrap={sidebar}>
@@ -74,24 +76,22 @@ export const FilterLine = observer(({ filter, availableFilters, index, view, sid
         <FilterOperation filter={filter} value={filter.currentValue} operator={filter.operator} field={filter.field} />
 
         {/* Render child filters (join filters) inline */}
-        {filter.view.filters
-          .filter((f) => (f.parent && f.parent === filter.id) || f.localParent === filter)
-          .map((child, idx) => {
-            console.debug("[DM] render child filter", { parent: filter, child });
-            return (
-              <Elem name="column" key={`child-${idx}`} mix="value">
-                <Tag size="small" className="filters-data-tag" color="#1d91e4" style={{ marginRight: 4 }}>
-                  {child.field.title}
-                </Tag>
-                <FilterOperation
-                  filter={child}
-                  value={child.currentValue}
-                  operator={child.operator}
-                  field={child.field}
-                />
-              </Elem>
-            );
-          })}
+        {childFilters.map((child, idx) => {
+          console.debug("[DM] render child filter", { parent: filter, child });
+          return (
+            <Elem name="column" key={`child-${idx}`} mix="value">
+              <Tag size="small" className="filters-data-tag" color="#1d91e4" style={{ marginRight: 4 }}>
+                {child.field.title}
+              </Tag>
+              <FilterOperation
+                filter={child}
+                value={child.currentValue}
+                operator={child.operator}
+                field={child.field}
+              />
+            </Elem>
+          );
+        })}
       </GroupWrapper>
       <Elem name="remove">
         <Button
diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 6e595b3f8cf0..f072d541954b 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -114,7 +114,8 @@ export const Tab = types
         return self.filters.filter((f) => f.target === self.target);
       }
       return self.filters.filter(
-        (f) => f.target === self.target && !f.field.isAnnotationResultsFilterColumn && !f.parent && !f.localParent,
+        (f) =>
+          f.target === self.target && !f.field.isAnnotationResultsFilterColumn && !f.parent && f.parent_index == null,
       );
     },
 
@@ -384,17 +385,16 @@ export const Tab = types
      * Used internally to materialize join filters.
      */
     createChildFilterForType(filterType, parentFilter) {
+      const parentIdx = self.filters.indexOf(parentFilter);
+
       const filter = TabFilter.create({
         filter: filterType.id ?? filterType,
-        parent: null,
+        parent_index: parentIdx,
       });
 
-      // keep local link until we know the backend id
-      filter.setLocalParent(parentFilter);
-
       self.filters.push(filter);
 
-      console.debug("[DM] child filter instantiated", { parentFilter, child: filter });
+      console.debug("[DM] child filter instantiated", { parentFilterIndex: parentIdx, child: filter });
 
       return filter;
     },
@@ -421,7 +421,10 @@ export const Tab = types
 
     deleteFilter(filter) {
       // Recursively delete child filters first
-      const childFilters = self.filters.filter((f) => (f.parent && f.parent === filter.id) || f.localParent === filter);
+      const parentIdx = self.filters.indexOf(filter);
+      const childFilters = self.filters.filter(
+        (f) => (f.parent && f.parent === filter.id) || f.parent_index === parentIdx,
+      );
 
       childFilters.forEach((child) => {
         self.deleteFilter(child);
@@ -496,7 +499,9 @@ export const Tab = types
         .filter((c) => joinFilters.includes(c.alias))
         .forEach((col) => {
           const exists = self.filters.find(
-            (f) => (f.parent === rootFilter.id || f.localParent === rootFilter) && f.filter.field.id === col.id,
+            (f) =>
+              (f.parent === rootFilter.id || f.parent_index === self.filters.indexOf(rootFilter)) &&
+              f.filter.field.id === col.id,
           );
 
           console.debug("[DM] join-filter check", { col: col.id, exists });
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_filter.js b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
index ba4ee1decad0..995f3da88809 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_filter.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
@@ -31,10 +31,9 @@ export const TabFilter = types
     value: types.maybeNull(FilterValueType),
 
     /**
-     * Backend id of the parent filter (root filter). For child filters only.
-     * For yet-unsaved children this is null until the parent receives its backend id.
+     * Index within the filters list of the parent filter (root filter). For child filters only.
      */
-    parent: types.maybeNull(types.number),
+    parent_index: types.maybeNull(types.number),
   })
   .views((self) => ({
     get field() {
@@ -103,9 +102,6 @@ export const TabFilter = types
     wasValid: false,
     saved: false,
     saving: false,
-
-    /** Temporary link to the parent TabFilter instance while the backend id is unknown */
-    localParent: null,
   }))
   .actions((self) => ({
     afterAttach() {
@@ -215,10 +211,6 @@ export const TabFilter = types
     saveDelayed: debounce(() => {
       self.save();
     }, 300),
-
-    setLocalParent(parent) {
-      self.localParent = parent;
-    },
   }))
   .preProcessSnapshot((sn) => {
     return { ...sn, value: sn.value ?? null };

From 45230c625654377128b7f24b42f46b033505488b Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 10:46:30 -0400
Subject: [PATCH 12/25] ff

---
 web/libs/datamanager/src/stores/Tabs/tab.js     | 14 +++++++++-----
 web/libs/datamanager/src/utils/feature-flags.js |  6 ++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index f072d541954b..05716083087d 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -8,7 +8,7 @@ import { TabSelectedItems } from "./tab_selected_items";
 import { History } from "../../utils/history";
 import { CustomJSON, StringOrNumberID, ThresholdType } from "../types";
 import { clamp } from "../../utils/helpers";
-import { FF_ANNOTATION_RESULTS_FILTERING, isFF } from "../../utils/feature-flags";
+import { FF_ANNOTATION_RESULTS_FILTERING, FF_BETTER_USER_FILTER, isFF } from "../../utils/feature-flags";
 
 const THRESHOLD_MIN = 0;
 const THRESHOLD_MIN_DIFF = 0.001;
@@ -113,10 +113,14 @@ export const Tab = types
       if (isFF(FF_ANNOTATION_RESULTS_FILTERING)) {
         return self.filters.filter((f) => f.target === self.target);
       }
-      return self.filters.filter(
-        (f) =>
-          f.target === self.target && !f.field.isAnnotationResultsFilterColumn && !f.parent && f.parent_index == null,
-      );
+
+      return self.filters.filter((f) => {
+        const targetMatches = f.target === self.target;
+        const annotationResultsOK = isFF(FF_ANNOTATION_RESULTS_FILTERING) || !f.field.isAnnotationResultsFilterColumn;
+        const parentIndexOK = isFF(FF_BETTER_USER_FILTER) || f.parent_index == null;
+
+        return targetMatches && annotationResultsOK && parentIndexOK;
+      });
     },
 
     get currentOrder() {
diff --git a/web/libs/datamanager/src/utils/feature-flags.js b/web/libs/datamanager/src/utils/feature-flags.js
index cd46b353374f..62076c1fc36a 100644
--- a/web/libs/datamanager/src/utils/feature-flags.js
+++ b/web/libs/datamanager/src/utils/feature-flags.js
@@ -66,6 +66,12 @@ export const FF_AVERAGE_AGREEMENT_SCORE_POPOVER = "fflag_feat_all_leap_2042_aver
  */
 export const FF_ANNOTATION_RESULTS_FILTERING = "fflag_root_13_annotation_results_filtering";
 
+/**
+ * Allow to filter tasks in Data Manager by annotation results and user annotated on the same annotation
+ * @link https://app.launchdarkly.com/projects/default/flags/fflag_root_45_better_user_filter
+ */
+export const FF_BETTER_USER_FILTER = "fflag_root_45_better_user_filter";
+
 // Customize flags
 const flags = {};
 

From cea1fe112eb72f2a4fb5832ffc72ec2318470b30 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 11:01:25 -0400
Subject: [PATCH 13/25] bugfix

---
 web/libs/datamanager/src/stores/Tabs/tab.js        | 2 +-
 web/libs/datamanager/src/stores/Tabs/tab_filter.js | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 05716083087d..35f2aaf3b714 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -392,7 +392,7 @@ export const Tab = types
       const parentIdx = self.filters.indexOf(parentFilter);
 
       const filter = TabFilter.create({
-        filter: filterType.id ?? filterType,
+        filter: filterType,
         parent_index: parentIdx,
       });
 
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_filter.js b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
index 995f3da88809..bdbd9b768431 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_filter.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
@@ -21,11 +21,6 @@ const getOperatorDefaultValue = (operator) => {
 
 export const TabFilter = types
   .model("TabFilter", {
-    /**
-     * Backend primary key. Undefined until the filter is saved and the API returns it.
-     */
-    id: types.maybeNull(types.number),
-
     filter: types.reference(TabFilterType),
     operator: types.maybeNull(Operators),
     value: types.maybeNull(FilterValueType),

From fccf1300a1bbb4329b16e831904e783b1deea084 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 11:09:27 -0400
Subject: [PATCH 14/25] filter counter bugfix

---
 web/libs/datamanager/src/stores/Tabs/tab.js | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 35f2aaf3b714..2eae279cd0d4 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -110,10 +110,6 @@ export const Tab = types
     },
 
     get currentFilters() {
-      if (isFF(FF_ANNOTATION_RESULTS_FILTERING)) {
-        return self.filters.filter((f) => f.target === self.target);
-      }
-
       return self.filters.filter((f) => {
         const targetMatches = f.target === self.target;
         const annotationResultsOK = isFF(FF_ANNOTATION_RESULTS_FILTERING) || !f.field.isAnnotationResultsFilterColumn;
@@ -141,7 +137,8 @@ export const Tab = types
     },
 
     get filtersApplied() {
-      return self.validFilters.length;
+      // count only parent filters
+      return self.validFilters.filter((f) => f.parent_index == null).length;
     },
 
     get validFilters() {

From 89e09b744fb02870cccc312c2a0ed9d2bf650f89 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 11:27:29 -0400
Subject: [PATCH 15/25] don't double-display child filters

---
 .../src/components/Filters/FilterLine/FilterLine.jsx     | 9 ++++++++-
 web/libs/datamanager/src/stores/Tabs/tab.js              | 6 +++---
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
index 0f426be16e5e..a73d2660f1f1 100644
--- a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
+++ b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
@@ -31,7 +31,14 @@ const GroupWrapper = ({ children, wrap = false }) => {
 };
 
 export const FilterLine = observer(({ filter, availableFilters, index, view, sidebar, dropdownClassName }) => {
-  const childFilters = filter.view.filters.filter((f) => f.parent_index === index);
+  // Determine this filter's position in the master filters array; child filters store
+  // a reference to their parent via this absolute index, not the index within the
+  // (potentially filtered) list rendered in the sidebar. Using the absolute index
+  // guarantees that child filters are rendered inline with their correct parent
+  // even when the sidebar list omits them.
+  const parentIdx = filter.view.filters.indexOf(filter);
+
+  const childFilters = filter.view.filters.filter((f) => f.parent_index === parentIdx);
 
   return (
     <Block name="filter-line" tag={Fragment}>
diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 2eae279cd0d4..b396fe59b9f9 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -8,7 +8,7 @@ import { TabSelectedItems } from "./tab_selected_items";
 import { History } from "../../utils/history";
 import { CustomJSON, StringOrNumberID, ThresholdType } from "../types";
 import { clamp } from "../../utils/helpers";
-import { FF_ANNOTATION_RESULTS_FILTERING, FF_BETTER_USER_FILTER, isFF } from "../../utils/feature-flags";
+import { FF_ANNOTATION_RESULTS_FILTERING, isFF } from "../../utils/feature-flags";
 
 const THRESHOLD_MIN = 0;
 const THRESHOLD_MIN_DIFF = 0.001;
@@ -113,9 +113,9 @@ export const Tab = types
       return self.filters.filter((f) => {
         const targetMatches = f.target === self.target;
         const annotationResultsOK = isFF(FF_ANNOTATION_RESULTS_FILTERING) || !f.field.isAnnotationResultsFilterColumn;
-        const parentIndexOK = isFF(FF_BETTER_USER_FILTER) || f.parent_index == null;
+        const isRoot = f.parent_index == null;
 
-        return targetMatches && annotationResultsOK && parentIndexOK;
+        return targetMatches && annotationResultsOK && isRoot;
       });
     },
 

From 50dda51e74595bff41d73410a8d22d9e80a198c4 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 13:30:44 -0400
Subject: [PATCH 16/25] apply child filters correctly

---
 label_studio/data_manager/managers.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/label_studio/data_manager/managers.py b/label_studio/data_manager/managers.py
index 85c433a51250..bb1acf494a95 100644
--- a/label_studio/data_manager/managers.py
+++ b/label_studio/data_manager/managers.py
@@ -2,8 +2,10 @@
 """
 import logging
 import re
+from collections import defaultdict
 from datetime import datetime
 from typing import ClassVar
+from functools import reduce
 
 import ujson as json
 from core.feature_flags import flag_set
@@ -261,11 +263,15 @@ def apply_filters(queryset, filters, project, request):
     if not filters:
         return queryset
 
+    index_to_filter_expressions: dict[int, list[Q]] = defaultdict(list)
+
     # convert conjunction to orm statement
-    filter_expressions = []
     custom_filter_expressions = load_func(settings.DATA_MANAGER_CUSTOM_FILTER_EXPRESSIONS)
 
     for _filter in filters.items:
+        # combine child filters with their parent in the same filter expression
+        index = _filter.index if _filter.index is not None else _filter.parent_index
+        filter_expressions = index_to_filter_expressions[index]
 
         # we can also have annotations filters
         if not _filter.filter.startswith('filter:tasks:') or _filter.value is None:
@@ -458,11 +464,13 @@ def apply_filters(queryset, filters, project, request):
     """
     if filters.conjunction == ConjunctionEnum.OR:
         result_filter = Q()
-        for filter_expression in filter_expressions:
+        for filter_expressions in index_to_filter_expressions.values():
+            filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             result_filter.add(filter_expression, Q.OR)
         queryset = queryset.filter(result_filter)
     else:
-        for filter_expression in filter_expressions:
+        for filter_expressions in index_to_filter_expressions.values():
+            filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             queryset = queryset.filter(filter_expression)
     return queryset
 

From a43ab3da1b4ca54b83be6c1a7cc6c70fc8e152b8 Mon Sep 17 00:00:00 2001
From: matt-bernstein <matt-bernstein@users.noreply.github.com>
Date: Wed, 18 Jun 2025 18:00:14 +0000
Subject: [PATCH 17/25] Apply pre-commit linters

Workflow run: https://github.com/HumanSignal/label-studio/actions/runs/15740108174
---
 label_studio/data_manager/managers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/label_studio/data_manager/managers.py b/label_studio/data_manager/managers.py
index bb1acf494a95..b8db9d067977 100644
--- a/label_studio/data_manager/managers.py
+++ b/label_studio/data_manager/managers.py
@@ -4,8 +4,8 @@
 import re
 from collections import defaultdict
 from datetime import datetime
-from typing import ClassVar
 from functools import reduce
+from typing import ClassVar
 
 import ujson as json
 from core.feature_flags import flag_set

From 30c3b2d5223ff55b6cc7589df64d0933b4ff0644 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 14:19:34 -0400
Subject: [PATCH 18/25] extend pydantic data model

---
 label_studio/data_manager/managers.py       | 4 ++--
 label_studio/data_manager/prepare_params.py | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/label_studio/data_manager/managers.py b/label_studio/data_manager/managers.py
index b8db9d067977..443103ee9a5f 100644
--- a/label_studio/data_manager/managers.py
+++ b/label_studio/data_manager/managers.py
@@ -268,9 +268,9 @@ def apply_filters(queryset, filters, project, request):
     # convert conjunction to orm statement
     custom_filter_expressions = load_func(settings.DATA_MANAGER_CUSTOM_FILTER_EXPRESSIONS)
 
-    for _filter in filters.items:
+    for index, _filter in enumerate(filters.items):
         # combine child filters with their parent in the same filter expression
-        index = _filter.index if _filter.index is not None else _filter.parent_index
+        index = _filter.parent_index if _filter.parent_index is not None else index
         filter_expressions = index_to_filter_expressions[index]
 
         # we can also have annotations filters
diff --git a/label_studio/data_manager/prepare_params.py b/label_studio/data_manager/prepare_params.py
index 9b1c6b586f70..3ced2c73800f 100644
--- a/label_studio/data_manager/prepare_params.py
+++ b/label_studio/data_manager/prepare_params.py
@@ -17,6 +17,7 @@ class Filter(BaseModel):
     operator: str
     type: str
     value: Union[StrictInt, StrictFloat, StrictBool, StrictStr, FilterIn, list]
+    parent_index: Optional[int] = None
 
 
 class ConjunctionEnum(Enum):

From 0918f2a7133f68afbec1bf54244fa4c78cf74304 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 16:37:39 -0400
Subject: [PATCH 19/25] fix child filter persistence

---
 web/libs/datamanager/src/stores/Tabs/tab.js   | 20 +++++++++++++++----
 .../datamanager/src/stores/Tabs/tab_filter.js |  9 ++++++---
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index b396fe59b9f9..230245cbd329 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -378,6 +378,9 @@ export const Tab = types
 
       self.filters.push(filter);
 
+      // Immediately materialize join filters for the default column, if any
+      self.applyJoinFilters(filter);
+
       if (filter.isValidFilter) self.save();
     },
 
@@ -500,14 +503,13 @@ export const Tab = types
         .filter((c) => joinFilters.includes(c.alias))
         .forEach((col) => {
           const exists = self.filters.find(
-            (f) =>
-              (f.parent === rootFilter.id || f.parent_index === self.filters.indexOf(rootFilter)) &&
-              f.filter.field.id === col.id,
+            (f) => f.parent_index === self.filters.indexOf(rootFilter) && f.filter.field.id === col.id,
           );
 
           console.debug("[DM] join-filter check", { col: col.id, exists });
 
-          if (!exists) {
+          // if (!exists) {
+          if (1) {
             const filterType = self.availableFilters.find((ft) => ft.field.id === col.id);
 
             if (filterType) {
@@ -520,6 +522,16 @@ export const Tab = types
           }
         });
     },
+
+    /** Remove any child filters previously created */
+    clearJoinFilters(rootFilter) {
+      const childFilters = self.filters.filter((f) => f.parent_index === self.filters.indexOf(rootFilter));
+
+      childFilters.forEach((child) => {
+        console.debug("[DM] join-filter removed", { child });
+        self.deleteFilter(child);
+      });
+    },
   }))
   .preProcessSnapshot((snapshot) => {
     if (snapshot === null) return snapshot;
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_filter.js b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
index bdbd9b768431..8eff69560264 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_filter.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
@@ -111,6 +111,9 @@ export const TabFilter = types
     setFilter(value, save = true) {
       if (!isDefined(value)) return;
 
+      // Remove previous child filters
+      self.view.clearJoinFilters(self);
+
       const previousFilterType = self.filter.currentType;
       const previousFilter = self.filter.id;
 
@@ -120,15 +123,15 @@ export const TabFilter = types
       const filterChanged = previousFilter !== self.filter.id;
 
       if (typeChanged || filterChanged) {
+        // Spawn child filters (join_filters)
+        self.view.applyJoinFilters(self);
+
         self.markUnsaved();
       }
 
       if (typeChanged) {
         self.setDefaultValue();
         self.setOperator(self.component[0].key);
-
-        // Spawn child filters (join_filters) via view action to stay within MST action boundaries
-        self.view.applyJoinFilters(self);
       }
 
       if (filterChanged) {

From 8804d782705d60d7083dfaebc57fb59f6e2442e7 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 16:59:38 -0400
Subject: [PATCH 20/25] wip persist from db

---
 label_studio/data_manager/serializers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index b796a3e44cdf..69678f8d915b 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -158,7 +158,7 @@ def to_representation(self, instance):
                     'value': f.value,
                 }
                 if f.parent_id:
-                    item['parent'] = f.parent_id
+                    item['parent_index'] = roots.values_list('id', flat=True).index(f.parent_id)
                 filters['items'].append(item)
             result['data']['filters'] = filters
 

From 1b11cd20b90fe35510ff42f4ac30d31ff821288b Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Wed, 18 Jun 2025 16:59:54 -0400
Subject: [PATCH 21/25] wip persist from db

---
 web/libs/datamanager/src/stores/Tabs/tab.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 230245cbd329..98513f28e0e8 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -508,8 +508,7 @@ export const Tab = types
 
           console.debug("[DM] join-filter check", { col: col.id, exists });
 
-          // if (!exists) {
-          if (1) {
+          if (!exists) {
             const filterType = self.availableFilters.find((ft) => ft.field.id === col.id);
 
             if (filterType) {

From c781a491a086f149d762f89e8a4915b066b4eb49 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Thu, 19 Jun 2025 13:43:13 -0400
Subject: [PATCH 22/25] wip remove parent_index from BE

---
 label_studio/data_manager/managers.py       | 12 +--
 label_studio/data_manager/models.py         |  2 +
 label_studio/data_manager/prepare_params.py |  4 +-
 label_studio/data_manager/serializers.py    | 91 +++++++++++----------
 4 files changed, 59 insertions(+), 50 deletions(-)

diff --git a/label_studio/data_manager/managers.py b/label_studio/data_manager/managers.py
index 443103ee9a5f..48366347b3f5 100644
--- a/label_studio/data_manager/managers.py
+++ b/label_studio/data_manager/managers.py
@@ -263,15 +263,15 @@ def apply_filters(queryset, filters, project, request):
     if not filters:
         return queryset
 
-    index_to_filter_expressions: dict[int, list[Q]] = defaultdict(list)
+    parent_id_to_filter_expressions: dict[int, list[Q]] = defaultdict(list)
 
     # convert conjunction to orm statement
     custom_filter_expressions = load_func(settings.DATA_MANAGER_CUSTOM_FILTER_EXPRESSIONS)
 
-    for index, _filter in enumerate(filters.items):
+    for _filter in filters.items:
         # combine child filters with their parent in the same filter expression
-        index = _filter.parent_index if _filter.parent_index is not None else index
-        filter_expressions = index_to_filter_expressions[index]
+        parent_id = _filter.parent_id if _filter.parent_id is not None else _filter.id
+        filter_expressions = parent_id_to_filter_expressions[parent_id]
 
         # we can also have annotations filters
         if not _filter.filter.startswith('filter:tasks:') or _filter.value is None:
@@ -464,12 +464,12 @@ def apply_filters(queryset, filters, project, request):
     """
     if filters.conjunction == ConjunctionEnum.OR:
         result_filter = Q()
-        for filter_expressions in index_to_filter_expressions.values():
+        for filter_expressions in parent_id_to_filter_expressions.values():
             filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             result_filter.add(filter_expression, Q.OR)
         queryset = queryset.filter(result_filter)
     else:
-        for filter_expressions in index_to_filter_expressions.values():
+        for filter_expressions in parent_id_to_filter_expressions.values():
             filter_expression = reduce(lambda x, y: x & y, filter_expressions)
             queryset = queryset.filter(filter_expression)
     return queryset
diff --git a/label_studio/data_manager/models.py b/label_studio/data_manager/models.py
index 234bc106ab90..ff42144a4da7 100644
--- a/label_studio/data_manager/models.py
+++ b/label_studio/data_manager/models.py
@@ -57,10 +57,12 @@ def get_prepare_tasks_params(self, add_selected_items=False):
             for f in self.filter_group.filters.all():
                 items.append(
                     dict(
+                        id=f.id,
                         filter=f.column,
                         operator=f.operator,
                         type=f.type,
                         value=f.value,
+                        parent_id=f.parent.id if f.parent else None,
                     )
                 )
             filters = dict(conjunction=self.filter_group.conjunction, items=items)
diff --git a/label_studio/data_manager/prepare_params.py b/label_studio/data_manager/prepare_params.py
index 3ced2c73800f..2462d699cd90 100644
--- a/label_studio/data_manager/prepare_params.py
+++ b/label_studio/data_manager/prepare_params.py
@@ -13,11 +13,13 @@ class FilterIn(BaseModel):
 
 
 class Filter(BaseModel):
+    id: Optional[int] = None  # Database ID of this filter (present in API responses)
+    parent_id: Optional[int] = None  # Parent filter DB ID (only for child filters)
+
     filter: str
     operator: str
     type: str
     value: Union[StrictInt, StrictFloat, StrictBool, StrictStr, FilterIn, list]
-    parent_index: Optional[int] = None
 
 
 class ConjunctionEnum(Enum):
diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index 69678f8d915b..d05330b805cb 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -22,14 +22,6 @@
 
 
 class FilterSerializer(serializers.ModelSerializer):
-    # Allow children filters to reference parent by root-filter index instead of DB id
-    parent_index = serializers.IntegerField(
-        required=False,
-        allow_null=True,
-        write_only=True,
-        help_text='Index of the parent filter inside the same FilterGroup (alternative to `parent` PK)',
-    )
-
     class Meta:
         model = Filter
         fields = '__all__'
@@ -122,17 +114,41 @@ def to_internal_value(self, data):
         if 'filter_group' not in data and conjunction:
             data['filter_group'] = {'conjunction': conjunction, 'filters': []}
             if 'items' in filters:
+                # Support two input formats:
+                # 1) "flat" list where potential children reference their parent via ``parent_index`` (legacy)
+                # 2) "nested" list where each root item may contain ``child_filters`` (new preferred format).
+
+                root_counter = 0  # keeps track of the current root filter index
+
+                def _append_filter(src_filter, parent_idx=None):
+                    """Convert a single filter JSON object into internal representation."""
+
+                    filter_payload = {
+                        'column': src_filter.get('filter', ''),
+                        'operator': src_filter.get('operator', ''),
+                        'type': src_filter.get('type', ''),
+                        'value': src_filter.get('value', {}),
+                    }
+
+                    # Explicit parent reference by DB id (rare in create requests)
+                    if src_filter.get('parent') is not None:
+                        filter_payload['parent'] = src_filter.get('parent')
+
+                    data['filter_group']['filters'].append(filter_payload)
+
+                # Iterate over top-level items (roots)
                 for f in filters['items']:
-                    data['filter_group']['filters'].append(
-                        {
-                            'column': f.get('filter', ''),
-                            'operator': f.get('operator', ''),
-                            'type': f.get('type', ''),
-                            'value': f.get('value', {}),
-                            'parent': f.get('parent'),
-                            'parent_index': f.get('parent_index'),
-                        }
-                    )
+                    # Root filter itself
+                    _append_filter(f)
+
+                    # Process potential nested children
+                    child_filters = f.get('child_filters', []) or []
+                    for child in child_filters:
+                        _append_filter(child, parent_idx=root_counter)
+
+                    # Increment root index AFTER children have been processed so that
+                    # subsequent roots receive the proper index.
+                    root_counter += 1
 
         ordering = _data.pop('ordering', {})
         data['ordering'] = ordering
@@ -150,15 +166,24 @@ def to_representation(self, instance):
             # Root filters first (ordered by index), followed by child filters (any order)
             roots = instance.filter_group.filters.filter(parent__isnull=True).order_by('index')
             children = instance.filter_group.filters.filter(parent__isnull=False)
+
             for f in list(roots) + list(children):
                 item = {
+                    'id': f.id,
                     'filter': f.column,
                     'operator': f.operator,
                     'type': f.type,
                     'value': f.value,
                 }
+
+                # Relationship hints
                 if f.parent_id:
-                    item['parent_index'] = roots.values_list('id', flat=True).index(f.parent_id)
+                    item['parent_id'] = f.parent_id
+                else:
+                    child_ids = list(f.children.all().values_list('id', flat=True))
+                    if child_ids:
+                        item['child_ids'] = child_ids
+
                 filters['items'].append(item)
             result['data']['filters'] = filters
 
@@ -181,11 +206,11 @@ def _create_filters(filter_group, filters_data):
           shown in the top-level ordering bar.
         """
 
-        # Pass 1 — create root filters (no parent/parent_index) and build index→object map
+        # Pass 1 — create root filters (no parent) and build index→object map
         index_to_filter = {}
         next_index = 0
         for filter_data in filters_data:
-            is_root = filter_data.get('parent') in (None, '') and filter_data.get('parent_index') in (None, '')
+            is_root = filter_data.get('parent') in (None, '')
 
             if not is_root:
                 continue
@@ -194,9 +219,6 @@ def _create_filters(filter_group, filters_data):
             filter_data['index'] = next_index
             next_index += 1
 
-            # Remove helper key before model instantiation
-            filter_data.pop('parent_index', None)
-
             root_obj = Filter.objects.create(**filter_data)
             filter_group.filters.add(root_obj)
             index_to_filter[root_obj.index] = root_obj
@@ -204,29 +226,12 @@ def _create_filters(filter_group, filters_data):
         # Pass 2 — create child filters, resolving parent via `parent` PK or `parent_index`
         for filter_data in filters_data:
             has_parent_pk = filter_data.get('parent') not in (None, '')
-            has_parent_index = filter_data.get('parent_index') not in (None, '')
 
-            if not (has_parent_pk or has_parent_index):
+            if not has_parent_pk:
                 # Already processed as a root filter
                 continue
 
-            fixed_data = filter_data.copy()
-
-            if has_parent_pk:
-                parent_obj = filter_group.filters.get(id=fixed_data['parent'])
-            else:
-                parent_idx = fixed_data.get('parent_index')
-                parent_obj = index_to_filter.get(parent_idx)
-                if parent_obj is None:
-                    raise serializers.ValidationError(
-                        f'parent_index={parent_idx} does not correspond to any root filter',
-                    )
-
-            fixed_data['parent'] = parent_obj
-            fixed_data['index'] = None  # Child filters do not participate in top-level ordering
-            fixed_data.pop('parent_index', None)
-
-            child_obj = Filter.objects.create(**fixed_data)
+            child_obj = Filter.objects.create(**filter_data)
             filter_group.filters.add(child_obj)
 
     def create(self, validated_data):

From f34ed29ac412d8558bb1bb55ce50a58aad7b81f5 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Thu, 19 Jun 2025 14:01:52 -0400
Subject: [PATCH 23/25] fix test

---
 label_studio/tests/data_manager/test_views_api.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/label_studio/tests/data_manager/test_views_api.py b/label_studio/tests/data_manager/test_views_api.py
index 317bc1f59e83..55f7ba23d98f 100644
--- a/label_studio/tests/data_manager/test_views_api.py
+++ b/label_studio/tests/data_manager/test_views_api.py
@@ -149,7 +149,10 @@ def test_views_api_filters(business_client, project_id):
     )
 
     assert response.status_code == 200, response.content
-    assert response.json()['data'] == payload['data']
+    response_data = response.json()['data']
+    for item in response_data['filters']['items']:
+        item.pop('id')
+    assert response_data == payload['data']
 
     updated_payload = dict(
         project=project_id,
@@ -187,7 +190,10 @@ def test_views_api_filters(business_client, project_id):
     )
 
     assert response.status_code == 200, response.content
-    assert response.json()['data'] == updated_payload['data']
+    response_data = response.json()['data']
+    for item in response_data['filters']['items']:
+        item.pop('id')
+    assert response_data == updated_payload['data']
 
 
 def test_views_ordered_by_id(business_client, project_id):

From addbecdc6ebbd5513e46450663ba5b67f1d39c97 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Fri, 20 Jun 2025 14:02:22 -0400
Subject: [PATCH 24/25] fix serializers

---
 label_studio/data_manager/serializers.py | 103 +++++++++++++----------
 1 file changed, 57 insertions(+), 46 deletions(-)

diff --git a/label_studio/data_manager/serializers.py b/label_studio/data_manager/serializers.py
index d05330b805cb..e3a8af1ba9c0 100644
--- a/label_studio/data_manager/serializers.py
+++ b/label_studio/data_manager/serializers.py
@@ -21,7 +21,31 @@
 from label_studio.core.utils.common import round_floats
 
 
+class RecursiveField(serializers.Serializer):
+    def to_representation(self, value):
+        parent = self.parent.parent  # the owning serializer instance
+        serializer = parent.__class__(value, context=self.context)
+        return serializer.data
+
+    def to_internal_value(self, data):
+        """Allow RecursiveField to be writable.
+
+        We instantiate the *parent* serializer class (which in this case is
+        ``FilterSerializer``) to validate the nested payload. The validated
+        data produced by that serializer is returned so that the enclosing
+        serializer (``FilterSerializer``) can include it in its own
+        ``validated_data`` structure.
+        """
+
+        parent_cls = self.parent.parent.__class__  # FilterSerializer
+        serializer = parent_cls(data=data, context=self.context)
+        serializer.is_valid(raise_exception=True)
+        return serializer.validated_data
+
+
 class FilterSerializer(serializers.ModelSerializer):
+    child_filters = RecursiveField(many=True, required=False)
+
     class Meta:
         model = Filter
         fields = '__all__'
@@ -115,12 +139,10 @@ def to_internal_value(self, data):
             data['filter_group'] = {'conjunction': conjunction, 'filters': []}
             if 'items' in filters:
                 # Support two input formats:
-                # 1) "flat" list where potential children reference their parent via ``parent_index`` (legacy)
-                # 2) "nested" list where each root item may contain ``child_filters`` (new preferred format).
-
-                root_counter = 0  # keeps track of the current root filter index
+                # 1) "flat" list where potential children reference their parent via ``parent``
+                # 2) "nested" list where each root item may contain ``child_filters``
 
-                def _append_filter(src_filter, parent_idx=None):
+                def _convert_filter(src_filter):
                     """Convert a single filter JSON object into internal representation."""
 
                     filter_payload = {
@@ -131,24 +153,17 @@ def _append_filter(src_filter, parent_idx=None):
                     }
 
                     # Explicit parent reference by DB id (rare in create requests)
-                    if src_filter.get('parent') is not None:
-                        filter_payload['parent'] = src_filter.get('parent')
+                    if (parent := src_filter.get('parent')) is not None:
+                        filter_payload['parent'] = parent
 
-                    data['filter_group']['filters'].append(filter_payload)
+                    if child_filters := src_filter.get('child_filters'):
+                        filter_payload['child_filters'] = [_convert_filter(child) for child in child_filters]
+
+                    return filter_payload
 
                 # Iterate over top-level items (roots)
                 for f in filters['items']:
-                    # Root filter itself
-                    _append_filter(f)
-
-                    # Process potential nested children
-                    child_filters = f.get('child_filters', []) or []
-                    for child in child_filters:
-                        _append_filter(child, parent_idx=root_counter)
-
-                    # Increment root index AFTER children have been processed so that
-                    # subsequent roots receive the proper index.
-                    root_counter += 1
+                    data['filter_group']['filters'].append(_convert_filter(f))
 
         ordering = _data.pop('ordering', {})
         data['ordering'] = ordering
@@ -177,12 +192,10 @@ def to_representation(self, instance):
                 }
 
                 # Relationship hints
-                if f.parent_id:
-                    item['parent_id'] = f.parent_id
-                else:
-                    child_ids = list(f.children.all().values_list('id', flat=True))
-                    if child_ids:
-                        item['child_ids'] = child_ids
+                if f.parent:
+                    item['parent'] = f.parent.id
+                if children := list(f.children.all().values_list('id', flat=True)):
+                    item['children'] = children
 
                 filters['items'].append(item)
             result['data']['filters'] = filters
@@ -206,33 +219,31 @@ def _create_filters(filter_group, filters_data):
           shown in the top-level ordering bar.
         """
 
-        # Pass 1 — create root filters (no parent) and build index→object map
-        index_to_filter = {}
-        next_index = 0
-        for filter_data in filters_data:
-            is_root = filter_data.get('parent') in (None, '')
+        def _create_recursive(data, parent=None, index=None):
 
-            if not is_root:
-                continue
+            # Extract nested children early (if any) and remove them from payload
+            children = data.pop('child_filters', [])
 
-            # Enumerate root filters for stable ordering
-            filter_data['index'] = next_index
-            next_index += 1
+            # Handle explicit parent reference present in the JSON payload only
+            # for root elements. For nested structures we rely on the actual
+            # ``parent`` FK object instead of its primary key.
+            if parent is not None:
+                data.pop('parent', None)
 
-            root_obj = Filter.objects.create(**filter_data)
-            filter_group.filters.add(root_obj)
-            index_to_filter[root_obj.index] = root_obj
+            # Assign display order for root filters
+            if parent is None:
+                data['index'] = index
 
-        # Pass 2 — create child filters, resolving parent via `parent` PK or `parent_index`
-        for filter_data in filters_data:
-            has_parent_pk = filter_data.get('parent') not in (None, '')
+            # Persist the filter
+            obj = Filter.objects.create(parent=parent, **data)
+            filter_group.filters.add(obj)
 
-            if not has_parent_pk:
-                # Already processed as a root filter
-                continue
+            # Recurse into children (if any)
+            for child in children:
+                _create_recursive(child, parent=obj)
 
-            child_obj = Filter.objects.create(**filter_data)
-            filter_group.filters.add(child_obj)
+        for index, data in enumerate(filters_data):
+            _create_recursive(data, index=index)
 
     def create(self, validated_data):
         with transaction.atomic():

From 7fff391dd9bf06dd529f974287a0ff760c3169c7 Mon Sep 17 00:00:00 2001
From: Matt Bernstein <matt@humansignal.com>
Date: Fri, 20 Jun 2025 15:19:38 -0400
Subject: [PATCH 25/25] remove parent_index in favor of parent, id

---
 label_studio/data_manager/managers.py         |  2 +-
 label_studio/data_manager/prepare_params.py   |  5 +++--
 .../Filters/FilterLine/FilterLine.jsx         |  9 +-------
 web/libs/datamanager/src/stores/Tabs/tab.js   | 21 +++++++------------
 .../datamanager/src/stores/Tabs/tab_filter.js |  9 ++++----
 5 files changed, 17 insertions(+), 29 deletions(-)

diff --git a/label_studio/data_manager/managers.py b/label_studio/data_manager/managers.py
index 48366347b3f5..4b866bc8c95b 100644
--- a/label_studio/data_manager/managers.py
+++ b/label_studio/data_manager/managers.py
@@ -270,7 +270,7 @@ def apply_filters(queryset, filters, project, request):
 
     for _filter in filters.items:
         # combine child filters with their parent in the same filter expression
-        parent_id = _filter.parent_id if _filter.parent_id is not None else _filter.id
+        parent_id = _filter.parent if _filter.parent is not None else _filter.id
         filter_expressions = parent_id_to_filter_expressions[parent_id]
 
         # we can also have annotations filters
diff --git a/label_studio/data_manager/prepare_params.py b/label_studio/data_manager/prepare_params.py
index 2462d699cd90..f97981b8edf9 100644
--- a/label_studio/data_manager/prepare_params.py
+++ b/label_studio/data_manager/prepare_params.py
@@ -13,8 +13,9 @@ class FilterIn(BaseModel):
 
 
 class Filter(BaseModel):
-    id: Optional[int] = None  # Database ID of this filter (present in API responses)
-    parent_id: Optional[int] = None  # Parent filter DB ID (only for child filters)
+    id: Optional[int] = None  # Database ID of this filter
+    parent: Optional[int] = None  # Parent filter DB ID (only for child filters)
+    children: Optional[List[int]] = None  # Child filter DB IDs
 
     filter: str
     operator: str
diff --git a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
index a73d2660f1f1..0fcf03381e42 100644
--- a/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
+++ b/web/libs/datamanager/src/components/Filters/FilterLine/FilterLine.jsx
@@ -31,14 +31,7 @@ const GroupWrapper = ({ children, wrap = false }) => {
 };
 
 export const FilterLine = observer(({ filter, availableFilters, index, view, sidebar, dropdownClassName }) => {
-  // Determine this filter's position in the master filters array; child filters store
-  // a reference to their parent via this absolute index, not the index within the
-  // (potentially filtered) list rendered in the sidebar. Using the absolute index
-  // guarantees that child filters are rendered inline with their correct parent
-  // even when the sidebar list omits them.
-  const parentIdx = filter.view.filters.indexOf(filter);
-
-  const childFilters = filter.view.filters.filter((f) => f.parent_index === parentIdx);
+  const childFilters = filter.view.filters.filter((f) => f.parent === filter.id);
 
   return (
     <Block name="filter-line" tag={Fragment}>
diff --git a/web/libs/datamanager/src/stores/Tabs/tab.js b/web/libs/datamanager/src/stores/Tabs/tab.js
index 98513f28e0e8..970ecefeadd4 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab.js
@@ -113,7 +113,7 @@ export const Tab = types
       return self.filters.filter((f) => {
         const targetMatches = f.target === self.target;
         const annotationResultsOK = isFF(FF_ANNOTATION_RESULTS_FILTERING) || !f.field.isAnnotationResultsFilterColumn;
-        const isRoot = f.parent_index == null;
+        const isRoot = f.parent == null;
 
         return targetMatches && annotationResultsOK && isRoot;
       });
@@ -138,7 +138,7 @@ export const Tab = types
 
     get filtersApplied() {
       // count only parent filters
-      return self.validFilters.filter((f) => f.parent_index == null).length;
+      return self.validFilters.filter((f) => f.parent == null).length;
     },
 
     get validFilters() {
@@ -389,16 +389,14 @@ export const Tab = types
      * Used internally to materialize join filters.
      */
     createChildFilterForType(filterType, parentFilter) {
-      const parentIdx = self.filters.indexOf(parentFilter);
-
       const filter = TabFilter.create({
         filter: filterType,
-        parent_index: parentIdx,
+        parent: parentFilter.id,
       });
 
       self.filters.push(filter);
 
-      console.debug("[DM] child filter instantiated", { parentFilterIndex: parentIdx, child: filter });
+      console.debug("[DM] child filter instantiated", { parentFilter: parentFilter.id, child: filter });
 
       return filter;
     },
@@ -425,10 +423,7 @@ export const Tab = types
 
     deleteFilter(filter) {
       // Recursively delete child filters first
-      const parentIdx = self.filters.indexOf(filter);
-      const childFilters = self.filters.filter(
-        (f) => (f.parent && f.parent === filter.id) || f.parent_index === parentIdx,
-      );
+      const childFilters = self.filters.filter((f) => f.parent === filter.id);
 
       childFilters.forEach((child) => {
         self.deleteFilter(child);
@@ -502,9 +497,7 @@ export const Tab = types
       self.targetColumns
         .filter((c) => joinFilters.includes(c.alias))
         .forEach((col) => {
-          const exists = self.filters.find(
-            (f) => f.parent_index === self.filters.indexOf(rootFilter) && f.filter.field.id === col.id,
-          );
+          const exists = self.filters.find((f) => f.parent === rootFilter.id && f.filter.field.id === col.id);
 
           console.debug("[DM] join-filter check", { col: col.id, exists });
 
@@ -524,7 +517,7 @@ export const Tab = types
 
     /** Remove any child filters previously created */
     clearJoinFilters(rootFilter) {
-      const childFilters = self.filters.filter((f) => f.parent_index === self.filters.indexOf(rootFilter));
+      const childFilters = self.filters.filter((f) => f.parent === rootFilter.id);
 
       childFilters.forEach((child) => {
         console.debug("[DM] join-filter removed", { child });
diff --git a/web/libs/datamanager/src/stores/Tabs/tab_filter.js b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
index 8eff69560264..9be725432bf1 100644
--- a/web/libs/datamanager/src/stores/Tabs/tab_filter.js
+++ b/web/libs/datamanager/src/stores/Tabs/tab_filter.js
@@ -25,10 +25,11 @@ export const TabFilter = types
     operator: types.maybeNull(Operators),
     value: types.maybeNull(FilterValueType),
 
-    /**
-     * Index within the filters list of the parent filter (root filter). For child filters only.
-     */
-    parent_index: types.maybeNull(types.number),
+    // DB ID of the Filter
+    id: types.maybeNull(types.int),
+
+    // DB ID of the parent Filter, if any
+    parent: types.maybeNull(types.int),
   })
   .views((self) => ({
     get field() {