fix: allow root assets to have non-unique names (#2226)

* fix: allow root assets to have non-unique names

Signed-off-by: Nicolas Höning <nicolas@seita.nl>

* fix: define account-scoped root asset index

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* fix: migrate account-scoped root asset index

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* fix: validate root asset names by account

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* test: cover root asset model uniqueness

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* test: cover root asset API uniqueness

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* test: avoid duplicate planning root asset name

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* Update documentation/changelog.rst

Co-authored-by: Felix Claessen <30658763+Flix6x@users.noreply.github.com>
Signed-off-by: Mohamed Belhsan Hmida <149331360+BelhsanHmida@users.noreply.github.com>

* fix: reuse toy root assets by account

The Docker build workflow runs `flexmeasures add toy-account` first and later runs `flexmeasures add toy-account --kind process` against the same database.

After adding account-scoped uniqueness for root asset names, the second command could no longer insert another top-level `toy-building` for the same account. Look up toy assets by the same identity that the database enforces instead: root assets by account/name and child assets by parent/name.

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* test: cover repeated toy account setup

Cover the Docker tutorial sequence where the battery toy account is created before extending the same account with process assets.

The regression checks that the second command reuses the existing root `toy-building`, keeps one root `toy-process`, and still adds the expected process sensors.

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* Update documentation/changelog.rst

Co-authored-by: Felix Claessen <30658763+Flix6x@users.noreply.github.com>
Signed-off-by: Mohamed Belhsan Hmida <149331360+BelhsanHmida@users.noreply.github.com>

* fix: enforce unique public root asset names

Public root assets do not belong to an account namespace, so duplicate names there would share one global public namespace.

Add a separate partial unique index for public root assets and validate that case in the asset schema instead of exempting account_id=None roots.

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

* test: cover public root asset name uniqueness

Update the model-level duplicate public root asset test to expect the new global uniqueness rule.

Add API coverage so duplicate public root names are rejected by schema validation before reaching the database.

Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>

---------

Signed-off-by: Nicolas Höning <nicolas@seita.nl>
Signed-off-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>
Signed-off-by: Mohamed Belhsan Hmida <149331360+BelhsanHmida@users.noreply.github.com>
Co-authored-by: Mohamed Belhsan Hmida <mohamedbelhsanhmida@gmail.com>
Co-authored-by: Mohamed Belhsan Hmida <149331360+BelhsanHmida@users.noreply.github.com>
Co-authored-by: Felix Claessen <30658763+Flix6x@users.noreply.github.com>

Author: 3 people

documentation/changelog.rst

@@ -21,6 +21,7 @@ Infrastructure / Support
 
 Bugfixes
 -----------
+* Allow root assets belonging to different accounts to share the same name, while keeping asset names unique among root assets within the same account and among children of the same parent [see `PR #2226 <https://www.github.com/FlexMeasures/flexmeasures/pull/2226>`_]
 
 
 v0.33.0 | June 1, 2026

flexmeasures/api/v3_0/tests/test_assets_api.py

@@ -614,24 +614,31 @@ def test_consultancy_user_without_consultant_role(
 
 
 @pytest.mark.parametrize(
-    "parent_name, child_name, fails",
+    "parent_name, child_name, pre_existing_root, fails",
     [
-        ("parent", "child_4", False),
-        (None, "child_1", False),
-        (None, "child_1", True),
-        ("parent", "child_1", True),
+        ("parent", "child_4", False, False),
+        (None, "child_1", False, False),
+        (None, "duplicate_root_name", True, True),
+        ("parent", "child_1", False, True),
     ],
 )
 @pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
 def test_post_an_asset_with_existing_name(
-    client, add_asset_with_children, parent_name, child_name, fails, requesting_user, db
+    client,
+    add_asset_with_children,
+    parent_name,
+    child_name,
+    pre_existing_root,
+    fails,
+    requesting_user,
+    db,
 ):
     """Catch DB error (Unique key violated) correctly.
 
     Cases:
         1) Create a child asset
         2) Create an orphan asset with a name that already exists under a parent asset
-        3) Create an orphan asset with an existing name.
+        3) Create an orphan asset with an existing root asset name in the same account.
         4) Create a child asset with a name that already exists among its siblings.
     """
 
@@ -650,10 +657,22 @@ def get_asset_by_name(asset_name):
     post_data["account_id"] = requesting_user.account_id
 
     if parent:
-        post_data["parent_asset_id"] = parent.parent_asset_id
+        post_data["parent_asset_id"] = parent.id
     else:
         post_data["parent_asset_id"] = None
 
+    if pre_existing_root:
+        db.session.add(
+            GenericAsset(
+                name=child_name,
+                generic_asset_type=add_asset_with_children[
+                    "child_1"
+                ].generic_asset_type,
+                account_id=requesting_user.account_id,
+            )
+        )
+        db.session.flush()
+
     asset_creation_response = client.post(
         url_for("AssetAPI:post"),
         json=post_data,

flexmeasures/api/v3_0/tests/test_assets_api_fresh_db.py

@@ -43,6 +43,64 @@ def test_post_an_asset_as_admin(client, setup_api_fresh_test_data, requesting_us
     assert asset.latitude == 30.1
 
 
+@pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
+def test_post_root_asset_allows_existing_name_in_different_account(
+    client, setup_api_fresh_test_data, requesting_user, fresh_db
+):
+    with AccountContext("Test Prosumer Account") as prosumer:
+        existing_asset = prosumer.generic_assets[0]
+        existing_name = existing_asset.name
+        asset_type_id = existing_asset.generic_asset_type_id
+
+    with AccountContext("Test Supplier Account") as supplier:
+        post_data = get_asset_post_data(
+            account_id=supplier.id,
+            asset_type_id=asset_type_id,
+        )
+    post_data["name"] = existing_name
+
+    response = client.post(
+        url_for("AssetAPI:post"),
+        json=post_data,
+    )
+
+    assert response.status_code == 201
+    assert response.json["name"] == existing_name
+    assert response.json["account_id"] == post_data["account_id"]
+    assert response.json["parent_asset_id"] is None
+
+
+@pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
+def test_post_public_root_asset_rejects_existing_name(
+    client, setup_api_fresh_test_data, requesting_user, fresh_db
+):
+    db = fresh_db
+    with AccountContext("Test Prosumer Account") as prosumer:
+        asset_type_id = prosumer.generic_assets[0].generic_asset_type_id
+
+    existing_name = "Existing public root asset"
+    db.session.add(
+        GenericAsset(
+            name=existing_name,
+            generic_asset_type_id=asset_type_id,
+            account_id=None,
+        )
+    )
+    db.session.flush()
+
+    post_data = get_asset_post_data(asset_type_id=asset_type_id)
+    post_data["name"] = existing_name
+    post_data.pop("account_id")
+
+    response = client.post(
+        url_for("AssetAPI:post"),
+        json=post_data,
+    )
+
+    assert response.status_code == 422
+    assert "already exists" in response.json["message"]["json"]["name"][0]
+
+
 @pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
 def test_edit_an_asset(client, setup_api_fresh_test_data, requesting_user, db):
     with AccountContext("Test Supplier Account") as supplier:
@@ -62,6 +120,34 @@ def test_edit_an_asset(client, setup_api_fresh_test_data, requesting_user, db):
     assert updated_asset.name == existing_asset.name
 
 
+@pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
+def test_patch_root_asset_rejects_existing_name_in_same_account(
+    client, setup_api_fresh_test_data, requesting_user, fresh_db
+):
+    db = fresh_db
+    with AccountContext("Test Prosumer Account") as prosumer:
+        existing_asset = prosumer.generic_assets[0]
+        existing_name = existing_asset.name
+        asset_type_id = existing_asset.generic_asset_type_id
+        account_id = prosumer.id
+
+    other_asset = GenericAsset(
+        name="Root asset to rename",
+        generic_asset_type_id=asset_type_id,
+        account_id=account_id,
+    )
+    db.session.add(other_asset)
+    db.session.flush()
+
+    response = client.patch(
+        url_for("AssetAPI:patch", id=other_asset.id),
+        json={"name": existing_name},
+    )
+
+    assert response.status_code == 422
+    assert "already exists" in response.json["message"]["json"]["name"][0]
+
+
 @pytest.mark.parametrize("requesting_user", ["test_admin_user@seita.nl"], indirect=True)
 def test_delete_an_asset(client, setup_api_fresh_test_data, requesting_user, db):
     with AccountContext("Test Prosumer Account") as prosumer:

flexmeasures/cli/data_add.py

@@ -1675,6 +1675,53 @@ def launch_editor(filename: str) -> dict:
         return content
 
 
+def get_or_create_toy_asset(
+    asset_name: str,
+    asset_type: str,
+    asset_types: dict[str, GenericAssetType],
+    account_owner: Account,
+    location: tuple[float, float],
+    parent_asset_id: int | None = None,
+    flex_context: dict | None = None,
+    flex_model: dict | None = None,
+    **asset_attributes,
+) -> GenericAsset:
+    asset_query = select(GenericAsset).filter_by(
+        name=asset_name,
+        account_id=account_owner.id,
+    )
+    if parent_asset_id is None:
+        asset_query = asset_query.filter(GenericAsset.parent_asset_id.is_(None))
+    else:
+        asset_query = asset_query.filter_by(parent_asset_id=parent_asset_id)
+    asset = db.session.execute(asset_query).scalar_one_or_none()
+
+    if asset is not None:
+        return asset
+
+    asset_kwargs: Dict[str, Any] = {}
+    if parent_asset_id is not None:
+        asset_kwargs["parent_asset_id"] = parent_asset_id
+    if flex_context is not None:
+        asset_kwargs["flex_context"] = flex_context
+    if flex_model is not None:
+        asset_kwargs["flex_model"] = flex_model
+
+    asset = GenericAsset(
+        name=asset_name,
+        generic_asset_type=asset_types[asset_type],
+        owner=account_owner,
+        latitude=location[0],
+        longitude=location[1],
+        attributes=asset_attributes,
+        **asset_kwargs,
+    )
+    db.session.add(asset)
+    db.session.flush()
+    click.echo(f"Created {repr(asset)}")
+    return asset
+
+
 @fm_add_data.command("toy-account")
 @with_appcontext
 @click.option(
@@ -1745,6 +1792,7 @@ def add_toy_account(kind: str, name: str):
     )
 
     account_id = user.account_id
+    account_owner = db.session.get(Account, account_id)
 
     def create_asset_with_one_sensor(
         asset_name: str,
@@ -1756,23 +1804,16 @@ def create_asset_with_one_sensor(
         flex_model: dict | None = None,
         **asset_attributes,
     ):
-        asset_kwargs: Dict[str, Any] = {}
-        if parent_asset_id is not None:
-            asset_kwargs["parent_asset_id"] = parent_asset_id
-        if flex_context is not None:
-            asset_kwargs["flex_context"] = flex_context
-        if flex_model is not None:
-            asset_kwargs["flex_model"] = flex_model
-
-        asset = get_or_create_model(
-            GenericAsset,
-            name=asset_name,
-            generic_asset_type=asset_types[asset_type],
-            owner=db.session.get(Account, account_id),
-            latitude=location[0],
-            longitude=location[1],
-            attributes=asset_attributes,
-            **asset_kwargs,
+        asset = get_or_create_toy_asset(
+            asset_name=asset_name,
+            asset_type=asset_type,
+            asset_types=asset_types,
+            account_owner=account_owner,
+            location=location,
+            parent_asset_id=parent_asset_id,
+            flex_context=flex_context,
+            flex_model=flex_model,
+            **asset_attributes,
         )
 
         sensor_specs = dict(
@@ -1789,13 +1830,12 @@ def create_asset_with_one_sensor(
         return sensor
 
     # create building asset
-    building_asset = get_or_create_model(
-        GenericAsset,
-        name="toy-building",
-        generic_asset_type=asset_types["building"],
-        owner=db.session.get(Account, account_id),
-        latitude=location[0],
-        longitude=location[1],
+    building_asset = get_or_create_toy_asset(
+        asset_name="toy-building",
+        asset_type="building",
+        asset_types=asset_types,
+        account_owner=account_owner,
+        location=location,
         flex_context={
             "site-power-capacity": "500 kVA",
             "consumption-price": {"sensor": day_ahead_sensor.id},

flexmeasures/cli/tests/test_data_add_fresh_db.py

@@ -374,6 +374,51 @@ def test_add_account(
         assert result.exit_code == 1
 
 
+def test_add_process_toy_account_reuses_existing_root_assets(app, fresh_db):
+    from flexmeasures.cli.data_add import add_toy_account
+
+    runner = app.test_cli_runner()
+    result = runner.invoke(add_toy_account)
+    assert result.exit_code == 0, result.output
+
+    result = runner.invoke(add_toy_account, ["--kind", "process"])
+    assert result.exit_code == 0, result.output
+
+    toy_account = fresh_db.session.execute(
+        select(Account).filter_by(name="Toy Account")
+    ).scalar_one()
+    root_buildings = (
+        fresh_db.session.execute(
+            select(Asset).filter_by(
+                name="toy-building",
+                owner=toy_account,
+                parent_asset_id=None,
+            )
+        )
+        .scalars()
+        .all()
+    )
+    root_processes = (
+        fresh_db.session.execute(
+            select(Asset).filter_by(
+                name="toy-process",
+                owner=toy_account,
+                parent_asset_id=None,
+            )
+        )
+        .scalars()
+        .all()
+    )
+
+    assert len(root_buildings) == 1
+    assert len(root_processes) == 1
+    assert {sensor.name for sensor in root_processes[0].sensors} == {
+        "Power (Inflexible)",
+        "Power (Breakable)",
+        "Power (Shiftable)",
+    }
+
+
 @pytest.mark.parametrize("storage_power_capacity", ["sensor", "quantity", None])
 @pytest.mark.parametrize("storage_efficiency", ["sensor", "quantity", None])
 def test_add_storage_schedule(

flexmeasures/data/migrations/versions/c7b7f9019d4b_allow_duplicate_root_asset_names.py

@@ -0,0 +1,58 @@
+"""Allow duplicate root asset names.
+
+Revision ID: c7b7f9019d4b
+Revises: b2c3d4e5f6a7
+Create Date: 2026-06-05 12:00:00.000000
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "c7b7f9019d4b"
+down_revision = "b2c3d4e5f6a7"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.drop_constraint(
+        "generic_asset_name_parent_asset_id_key", "generic_asset", type_="unique"
+    )
+    op.create_index(
+        "generic_asset_name_parent_asset_id_key",
+        "generic_asset",
+        ["name", "parent_asset_id"],
+        unique=True,
+        postgresql_where=sa.text("parent_asset_id IS NOT NULL"),
+        sqlite_where=sa.text("parent_asset_id IS NOT NULL"),
+    )
+    op.create_index(
+        "generic_asset_root_account_id_name_key",
+        "generic_asset",
+        ["account_id", "name"],
+        unique=True,
+        postgresql_where=sa.text("parent_asset_id IS NULL AND account_id IS NOT NULL"),
+        sqlite_where=sa.text("parent_asset_id IS NULL AND account_id IS NOT NULL"),
+    )
+    op.create_index(
+        "generic_asset_public_root_name_key",
+        "generic_asset",
+        ["name"],
+        unique=True,
+        postgresql_where=sa.text("parent_asset_id IS NULL AND account_id IS NULL"),
+        sqlite_where=sa.text("parent_asset_id IS NULL AND account_id IS NULL"),
+    )
+
+
+def downgrade():
+    op.drop_index("generic_asset_public_root_name_key", table_name="generic_asset")
+    op.drop_index("generic_asset_root_account_id_name_key", table_name="generic_asset")
+    op.drop_index("generic_asset_name_parent_asset_id_key", table_name="generic_asset")
+    op.create_unique_constraint(
+        "generic_asset_name_parent_asset_id_key",
+        "generic_asset",
+        ["name", "parent_asset_id"],
+    )