infrahub-server 1.4.4__tar.gz → 1.4.6__tar.gz

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.4.4
+Version: 1.4.6
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: Apache-2.0
 Author: OpsMill

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/actions/constants.py

@@ -118,6 +118,12 @@ class ValueMatch(DropdownEnum):
         description="Match against both the current and previous values",
         color="#5ac8fa",
     )
+    ANY = DropdownChoice(
+        name="any",
+        label="Any",
+        description="Match against any value",
+        color="#276cc2",
+    )
 
 
 NODES_THAT_TRIGGER_ACTION_RULES_SETUP = [

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/api/query.py

@@ -40,7 +40,7 @@ router = APIRouter(prefix="/query")
 
 
 class QueryPayload(BaseModel):
-    variables: dict[str, str] = Field(default_factory=dict)
+    variables: dict[str, Any] = Field(default_factory=dict)
 
 
 async def execute_query(
@@ -48,7 +48,7 @@ async def execute_query(
     request: Request,
     branch_params: BranchParams,
     query_id: str,
-    params: dict[str, str],
+    params: dict[str, Any],
     update_group: bool,
     subscribers: list[str],
     permission_checker: GraphQLQueryPermissionChecker,

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/core/account.py

@@ -5,9 +5,10 @@ from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
 
-from infrahub.core.constants import InfrahubKind, PermissionDecision
+from infrahub.core.constants import NULL_VALUE, InfrahubKind, PermissionDecision
 from infrahub.core.query import Query, QueryType
 from infrahub.core.registry import registry
+from infrahub.core.timestamp import Timestamp
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -519,47 +520,72 @@ class AccountTokenValidateQuery(Query):
         super().__init__(**kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        token_filter_perms, token_params = self.branch.get_query_filter_relationships(
-            rel_labels=["r1", "r2"], at=self.at, include_outside_parentheses=True
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at.to_string(), branch_agnostic=self.branch_agnostic, is_isolated=False
         )
-        self.params.update(token_params)
-
-        account_filter_perms, account_params = self.branch.get_query_filter_relationships(
-            rel_labels=["r31", "r41", "r5", "r6"], at=self.at, include_outside_parentheses=True
+        self.params.update(branch_params)
+        self.params.update(
+            {
+                "token_attr_name": "token",
+                "token_relationship_name": "account__token",
+                "token_value": self.token,
+                "null_value": NULL_VALUE,
+            }
         )
-        self.params.update(account_params)
 
-        self.params["token_value"] = self.token
-
-        # ruff: noqa: E501
         query = """
-        MATCH (at:InternalAccountToken)-[r1:HAS_ATTRIBUTE]-(a:Attribute {name: "token"})-[r2:HAS_VALUE]-(av:AttributeValue { value: $token_value })
-        WHERE %s
-        WITH at
-        MATCH (at)-[r31]-(:Relationship)-[r41]-(acc:CoreGenericAccount)-[r5:HAS_ATTRIBUTE]-(an:Attribute {name: "name"})-[r6:HAS_VALUE]-(av:AttributeValue)
-        WHERE %s
-        """ % (
-            "\n AND ".join(token_filter_perms),
-            "\n AND ".join(account_filter_perms),
-        )
-
+// --------------
+// get the active token node for this token value, if it exists
+// --------------
+MATCH (token_node:%(token_node_kind)s)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: $token_attr_name})
+    -[r2:HAS_VALUE]->(av:AttributeValueIndexed { value: $token_value })
+WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
+ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+LIMIT 1
+WITH token_node
+WHERE r1.status = "active" AND r2.status = "active"
+// --------------
+// get the expiration time
+// --------------
+OPTIONAL MATCH (token_node)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "expiration"})
+    -[r2:HAS_VALUE]->(av)
+WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
+ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+LIMIT 1
+WITH token_node, CASE
+    WHEN r1.status = "active" AND r2.status = "active" AND av.value <> $null_value THEN av.value
+    ELSE NULL
+END AS expiration
+// --------------
+// get the linked account node from the token node
+// --------------
+MATCH (token_node)-[r1:IS_RELATED]-(:Relationship {name: $token_relationship_name})-[r2:IS_RELATED]-(account_node:%(account_node_kind)s)
+WHERE all(r in [r1, r2] WHERE (%(branch_filter)s))
+ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+LIMIT 1
+WITH expiration, account_node
+WHERE r1.status = "active" AND r2.status = "active"
+        """ % {
+            "branch_filter": branch_filter,
+            "token_node_kind": InfrahubKind.ACCOUNTTOKEN,
+            "account_node_kind": InfrahubKind.GENERICACCOUNT,
+        }
         self.add_to_query(query)
-
-        self.return_labels = ["at", "av", "acc"]
-
-    def get_account_name(self) -> str | None:
-        """Return the account name that matched the query or None."""
-        if result := self.get_result():
-            return result.get("av").get("value")
-
-        return None
+        self.return_labels = ["account_node.uuid AS account_uuid", "expiration"]
 
     def get_account_id(self) -> str | None:
         """Return the account id that matched the query or a None."""
-        if result := self.get_result():
-            return result.get("acc").get("uuid")
-
-        return None
+        result = self.get_result()
+        if not result:
+            return None
+        account_uuid = result.get_as_str(label="account_uuid")
+        expiration_with_tz = result.get_as_str(label="expiration")
+        if expiration_with_tz is None:
+            return account_uuid
+        expiration = Timestamp(expiration_with_tz)
+        if expiration < Timestamp():
+            return None
+        return account_uuid
 
 
 async def validate_token(token: str, db: InfrahubDatabase, branch: Branch | str | None = None) -> str | None:

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/core/query/ipam.py

@@ -375,6 +375,10 @@ class IPPrefixReconcileQuery(Query):
         // ------------------
         MATCH (ip_namespace:%(namespace_kind)s {uuid: $namespace_id})-[r:IS_PART_OF]->(root:Root)
         WHERE %(branch_filter)s
+        ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+        LIMIT 1
+        WITH ip_namespace
+        WHERE r.status = "active"
         """ % {"branch_filter": branch_filter, "namespace_kind": self.params["namespace_kind"]}
         self.add_to_query(namespace_query)
 
@@ -384,8 +388,13 @@ class IPPrefixReconcileQuery(Query):
             // ------------------
             // Get IP Prefix node by UUID
             // ------------------
-            MATCH (ip_node:%(ip_kind)s {uuid: $node_uuid})
+            OPTIONAL MATCH (ip_node:%(ip_kind)s {uuid: $node_uuid})-[r:IS_PART_OF]->(:Root)
+            WHERE %(branch_filter)s
+            ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+            LIMIT 1
+            WITH ip_namespace, ip_node
             """ % {
+                "branch_filter": branch_filter,
                 "ip_kind": InfrahubKind.IPADDRESS
                 if isinstance(self.ip_value, IPAddressType)
                 else InfrahubKind.IPPREFIX,
@@ -395,17 +404,35 @@ class IPPrefixReconcileQuery(Query):
         else:
             get_node_by_prefix_query = """
             // ------------------
-            // Get IP Prefix node by prefix value
+            // Get IP node with the correct value on this branch
             // ------------------
-            OPTIONAL MATCH ip_node_path = (:Root)<-[:IS_PART_OF]-(ip_node:%(ip_kind)s)
-            -[:HAS_ATTRIBUTE]->(a:Attribute)-[:HAS_VALUE]->(aipn:%(ip_attribute_kind)s),
-            (ip_namespace)-[:IS_RELATED]-(nsr:Relationship)
-            -[:IS_RELATED]-(ip_node)
-            WHERE nsr.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
-            AND aipn.binary_address = $prefix_binary_full
+            OPTIONAL MATCH (:Root)<-[r1:IS_PART_OF]-(ip_node:%(ip_kind)s)
+                -[r2:HAS_ATTRIBUTE]->(a:Attribute)-[r3:HAS_VALUE]->(aipn:%(ip_attribute_kind)s)
+            WHERE aipn.binary_address = $prefix_binary_full
             AND aipn.prefixlen = $prefixlen
             AND aipn.version = $ip_version
-            AND all(r IN relationships(ip_node_path) WHERE (%(branch_filter)s) and r.status = "active")
+            AND all(r IN [r1, r2, r3] WHERE (%(branch_filter)s))
+            ORDER BY r3.branch_level DESC, r3.from DESC, r3.status ASC,
+                r2.branch_level DESC, r2.from DESC, r2.status ASC,
+                r1.branch_level DESC, r1.from DESC, r1.status ASC
+            LIMIT 1
+            WITH ip_namespace, CASE
+                WHEN ip_node IS NOT NULL AND r1.status = "active" AND r2.status = "active" AND r3.status = "active" THEN ip_node
+                ELSE NULL
+            END AS ip_node
+            // ------------------
+            // Filter to only those that are in the correct namespace
+            // ------------------
+            OPTIONAL MATCH (ip_namespace)-[r1:IS_RELATED]-(nsr:Relationship)-[r2:IS_RELATED]-(ip_node)
+            WHERE nsr.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
+            AND all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC,
+                r2.branch_level DESC, r2.from DESC, r2.status ASC
+            LIMIT 1
+            WITH ip_namespace, CASE
+                WHEN ip_node IS NOT NULL AND r1.status = "active" AND r2.status = "active" THEN ip_node
+                ELSE NULL
+            END as ip_node
             """ % {
                 "branch_filter": branch_filter,
                 "ip_kind": InfrahubKind.IPADDRESS
@@ -425,7 +452,7 @@ class IPPrefixReconcileQuery(Query):
             OPTIONAL MATCH parent_prefix_path = (ip_node)-[r1:IS_RELATED]->(:Relationship {name: "parent__child"})-[r2:IS_RELATED]->(current_parent:%(ip_prefix_kind)s)
             WHERE all(r IN relationships(parent_prefix_path) WHERE (%(branch_filter)s))
             RETURN current_parent, (r1.status = "active" AND r2.status = "active") AS parent_is_active
-            ORDER BY r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC
+            ORDER BY r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
             LIMIT 1
         }
         WITH ip_namespace, ip_node, CASE WHEN parent_is_active THEN current_parent ELSE NULL END as current_parent
@@ -474,28 +501,66 @@ class IPPrefixReconcileQuery(Query):
         // Identify the correct parent, if any, for the prefix node
         // ------------------
         CALL (ip_namespace) {
-            OPTIONAL MATCH parent_path = (ip_namespace)-[pr1:IS_RELATED {status: "active"}]-(ns_rel:Relationship {name: "ip_namespace__ip_prefix"})
-            -[pr2:IS_RELATED {status: "active"}]-(maybe_new_parent:%(ip_prefix_kind)s)
-            -[har:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})
-            -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
-            USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
-            WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
-            AND av.version = $ip_version
+            // ------------------
+            // start with just the AttributeValue vertices b/c we have an index on them
+            // ------------------
+            OPTIONAL MATCH (av:%(ip_prefix_attribute_kind)s)
+            WHERE av.version = $ip_version
             AND av.binary_address IN $possible_prefix_list
             AND any(prefix_and_length IN $possible_prefix_and_length_list WHERE av.binary_address = prefix_and_length[0] AND av.prefixlen <= prefix_and_length[1])
+            // ------------------
+            // now get all the possible IPPrefix nodes for these AttributeValues
+            // ------------------
+            OPTIONAL MATCH parent_path = (ip_namespace)-[:IS_RELATED]-(:Relationship {name: "ip_namespace__ip_prefix"})
+            -[:IS_RELATED]-(maybe_new_parent:%(ip_prefix_kind)s)
+            -[:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})
+            -[:HAS_VALUE]->(av:AttributeValue)
+            WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
+            RETURN DISTINCT maybe_new_parent
+        }
+        CALL (ip_namespace, maybe_new_parent) {
+            // ------------------
+            // filter to only active maybe_new_parent Nodes in the correct namespace
+            // ------------------
+            OPTIONAL MATCH (ip_namespace)-[r1:IS_RELATED]-(:Relationship {name: "ip_namespace__ip_prefix"})-[r2:IS_RELATED]-(maybe_new_parent)
+            WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH maybe_new_parent, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY elementId(maybe_new_parent), r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            WITH maybe_new_parent, head(collect(is_active)) AS is_active
+            RETURN is_active = TRUE AS parent_in_namespace
+        }
+        CALL (maybe_new_parent) {
+            // ------------------
+            // filter to only active maybe_new_parent Nodes currently linked to one of the allowed AttributeValues
+            // ------------------
+            OPTIONAL MATCH (maybe_new_parent)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "prefix"})-[r2:HAS_VALUE]->(av:AttributeValue)
+            WHERE all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH maybe_new_parent, av, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY elementId(maybe_new_parent), r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            // ------------------
+            // get the latest active attribute value for the maybe_new_parent
+            // ------------------
+            WITH maybe_new_parent, head(collect([av, is_active])) AS av_is_active
             WITH
-                maybe_new_parent,
-                har,
-                hvr,
-                av.prefixlen as prefixlen,
-                (har.status = "active" AND hvr.status = "active") AS is_active,
-                har.branch_level + hvr.branch_level AS branch_level
-            ORDER BY branch_level DESC, har.from DESC, hvr.from DESC
-            WITH maybe_new_parent, prefixlen, is_active
-            RETURN maybe_new_parent, head(collect(prefixlen)) AS mnp_prefixlen, head(collect(is_active)) AS mnp_is_active
+                av_is_active[0] AS av,
+                av_is_active[1] AS is_active
+            // ------------------
+            // return NULL if the value is not allowed or if it is not active
+            // ------------------
+            WITH av, is_active, (
+                av.version = $ip_version
+                AND av.binary_address IN $possible_prefix_list
+                AND any(prefix_and_length IN $possible_prefix_and_length_list WHERE av.binary_address = prefix_and_length[0] AND av.prefixlen <= prefix_and_length[1])
+            ) AS is_allowed_value
+            RETURN CASE WHEN is_active = TRUE AND is_allowed_value = TRUE THEN av ELSE NULL END AS allowed_av
         }
-        WITH ip_namespace, ip_node, current_parent, current_children, mnp_prefixlen,
-            CASE WHEN mnp_is_active THEN maybe_new_parent ELSE NULL END AS maybe_new_parent
+        // ------------------
+        // set inactive maybe_new_parents to NULL
+        // ------------------
+        WITH ip_namespace, ip_node, current_parent, current_children, allowed_av.prefixlen AS mnp_prefixlen,
+            CASE WHEN parent_in_namespace = TRUE AND allowed_av IS NOT NULL
+                THEN maybe_new_parent ELSE NULL
+            END AS maybe_new_parent
         WITH ip_namespace, ip_node, current_parent, current_children, maybe_new_parent, mnp_prefixlen
         ORDER BY ip_node.uuid, mnp_prefixlen DESC
         WITH ip_namespace, ip_node, current_parent, current_children, head(collect(maybe_new_parent)) as new_parent
@@ -511,19 +576,18 @@ class IPPrefixReconcileQuery(Query):
         // Identify the correct children, if any, for the prefix node
         // ------------------
         CALL (ip_namespace, ip_node) {
+            // ------------------
             // Get ALL possible children for the prefix node
-            OPTIONAL MATCH child_path = (
-                 (ip_namespace)-[r1:IS_RELATED]
-                 -(ns_rel:Relationship)-[r2:IS_RELATED]
-                 -(maybe_new_child:%(ip_prefix_kind)s|%(ip_address_kind)s)-[har:HAS_ATTRIBUTE]
-                 ->(a:Attribute)-[hvr:HAS_VALUE]
-                 ->(av:%(ip_prefix_attribute_kind)s|%(ip_address_attribute_kind)s)
+            // ------------------
+            OPTIONAL MATCH (
+                 (ip_namespace)-[:IS_RELATED]-(ns_rel:Relationship)-[:IS_RELATED]
+                 -(maybe_new_child:%(ip_prefix_kind)s|%(ip_address_kind)s)-[:HAS_ATTRIBUTE]
+                 ->(a:Attribute)-[:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s|%(ip_address_attribute_kind)s)
             )
             USING INDEX av:%(ip_prefix_attribute_kind)s(binary_address)
             USING INDEX av:%(ip_address_attribute_kind)s(binary_address)
             WHERE $is_prefix  // only prefix nodes can have children
             AND ns_rel.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
-            AND any(child_kind IN [$ip_prefix_kind, $ip_address_kind] WHERE child_kind IN labels(maybe_new_child))
             AND a.name in ["prefix", "address"]
             AND (ip_node IS NULL OR maybe_new_child.uuid <> ip_node.uuid)
             AND (
@@ -532,22 +596,58 @@ class IPPrefixReconcileQuery(Query):
             )
             AND av.version = $ip_version
             AND av.binary_address STARTS WITH $prefix_binary_host
-            AND all(r IN relationships(child_path) WHERE (%(branch_filter)s))
+            RETURN DISTINCT maybe_new_child
+        }
+        CALL (ip_namespace, maybe_new_child) {
+            // ------------------
+            // filter to only active maybe_new_child Nodes in the correct namespace
+            // ------------------
+            OPTIONAL MATCH (ip_namespace)-[r1:IS_RELATED]-(ns_rel:Relationship)-[r2:IS_RELATED]-(maybe_new_child)
+            WHERE ns_rel.name IN ["ip_namespace__ip_prefix", "ip_namespace__ip_address"]
+            AND all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH maybe_new_child, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY elementId(maybe_new_child), r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            WITH maybe_new_child, head(collect(is_active)) AS is_active
+            RETURN is_active = TRUE AS child_in_namespace
+        }
+        CALL (maybe_new_child) {
+            // ------------------
+            // filter to only active maybe_new_child Nodes currently linked to a possible child AttributeValue
+            // ------------------
+            OPTIONAL MATCH (maybe_new_child:%(ip_prefix_kind)s|%(ip_address_kind)s)-[r1:HAS_ATTRIBUTE]->(a:Attribute)-[r2:HAS_VALUE]->(av:AttributeValue)
+            WHERE a.name in ["prefix", "address"]
+            AND all(r IN [r1, r2] WHERE (%(branch_filter)s))
+            WITH maybe_new_child, av, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY elementId(maybe_new_child), r1.branch_level DESC, r1.from DESC, r1.status ASC, r2.branch_level DESC, r2.from DESC, r2.status ASC
+            // ------------------
+            // get the latest active attribute value for the maybe_new_child
+            // ------------------
+            WITH maybe_new_child, head(collect([av, is_active])) AS av_is_active
             WITH
-                maybe_new_child,
-                av AS mnc_attribute,
-                r1,
-                r2,
-                har,
-                hvr,
-                all(r in relationships(child_path) WHERE r.status = "active") AS is_active,
-                reduce(br_lvl = 0, r in relationships(child_path) | br_lvl + r.branch_level) AS branch_level
-            ORDER BY maybe_new_child.uuid, branch_level DESC, hvr.from DESC, har.from DESC, r2.from DESC, r1.from DESC
-            WITH maybe_new_child, head(collect([mnc_attribute, is_active])) AS latest_mnc_details
-            RETURN maybe_new_child, latest_mnc_details[0] AS latest_mnc_attribute, latest_mnc_details[1] AS mnc_is_active
+                av_is_active[0] AS av,
+                av_is_active[1] AS is_active
+            // ------------------
+            // return NULL if the value is not allowed or if it is not active
+            // ------------------
+            WITH av, is_active, (
+                (
+                    ($ip_prefix_kind IN labels(maybe_new_child) AND av.prefixlen > $prefixlen)
+                    OR ($ip_address_kind IN labels(maybe_new_child) AND av.prefixlen >= $prefixlen)
+                )
+                AND av.version = $ip_version
+                AND av.binary_address STARTS WITH $prefix_binary_host
+            ) AS is_allowed_value
+            RETURN CASE WHEN is_active = TRUE AND is_allowed_value = TRUE THEN av ELSE NULL END AS latest_mnc_attribute
         }
-        WITH ip_namespace, ip_node, current_parent, current_children, new_parent, latest_mnc_attribute,
-            CASE WHEN mnc_is_active IN [TRUE, NULL] THEN maybe_new_child ELSE NULL END AS maybe_new_child
+        // ------------------
+        // set inactive/illegal value/wrong namespace maybe_new_children to NULL
+        // ------------------
+        WITH ip_namespace, ip_node, current_parent, current_children, new_parent,
+            CASE
+                WHEN child_in_namespace = TRUE AND latest_mnc_attribute IS NOT NULL THEN maybe_new_child
+                ELSE NULL
+            END AS maybe_new_child,
+            CASE WHEN child_in_namespace = TRUE THEN latest_mnc_attribute ELSE NULL END AS latest_mnc_attribute
         WITH ip_namespace, ip_node, current_parent, current_children, new_parent, collect([maybe_new_child, latest_mnc_attribute]) AS maybe_children_ips
         WITH ip_namespace, ip_node, current_parent, current_children, new_parent, maybe_children_ips, range(0, size(maybe_children_ips) - 1) AS child_indices
         UNWIND child_indices as ind
@@ -581,9 +681,9 @@ class IPPrefixReconcileQuery(Query):
             new_parent,
             collect(new_child) as new_children
         """ % {
-            "branch_filter": branch_filter,
             "ip_prefix_kind": InfrahubKind.IPPREFIX,
             "ip_address_kind": InfrahubKind.IPADDRESS,
+            "branch_filter": branch_filter,
             "ip_prefix_attribute_kind": PREFIX_ATTRIBUTE_LABEL,
             "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/generators/tasks.py

@@ -168,6 +168,15 @@ async def request_generator_definition_run(
 
     client = get_client()
 
+    # Needs to be fetched before fetching group members otherwise `object` relationship would override
+    # existing node in client store without the `name` attribute due to #521
+    existing_instances = await client.filters(
+        kind=InfrahubKind.GENERATORINSTANCE,
+        definition__ids=[model.generator_definition.definition_id],
+        include=["object"],
+        branch=model.branch,
+    )
+
     group = await client.get(
         kind=InfrahubKind.GENERICGROUP,
         prefetch_relationships=True,
@@ -177,12 +186,6 @@ async def request_generator_definition_run(
     )
     await group.members.fetch()
 
-    existing_instances = await client.filters(
-        kind=InfrahubKind.GENERATORINSTANCE,
-        definition__ids=[model.generator_definition.definition_id],
-        include=["object"],
-        branch=model.branch,
-    )
     instance_by_member = {}
     for instance in existing_instances:
         instance_by_member[instance.object.peer.id] = instance.id

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/git/tasks.py

@@ -310,6 +310,15 @@ async def generate_request_artifact_definition(
 
     client = get_client()
 
+    # Needs to be fetched before fetching group members otherwise `object` relationship would override
+    # existing node in client store without the `name` attribute due to #521
+    existing_artifacts = await client.filters(
+        kind=CoreArtifact,
+        definition__ids=[model.artifact_definition_id],
+        include=["object"],
+        branch=model.branch,
+    )
+
     artifact_definition = await client.get(
         kind=CoreArtifactDefinition, id=model.artifact_definition_id, branch=model.branch
     )
@@ -319,12 +328,6 @@ async def generate_request_artifact_definition(
     await group.members.fetch()
     current_members = [member.id for member in group.members.peers]
 
-    existing_artifacts = await client.filters(
-        kind=CoreArtifact,
-        definition__ids=[model.artifact_definition_id],
-        include=["object"],
-        branch=model.branch,
-    )
     artifacts_by_member = {}
     for artifact in existing_artifacts:
         if artifact.object.id in current_members:

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/backend/infrahub/proposed_change/tasks.py

@@ -646,16 +646,19 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, c
         context=context,
     )
 
-    await artifact_definition.targets.fetch()
-    group = artifact_definition.targets.peer
-    await group.members.fetch()
-
+    # Needs to be fetched before fetching group members otherwise `object` relationship would override
+    # existing node in client store without the `name` attribute due to #521
     existing_artifacts = await client.filters(
         kind=InfrahubKind.ARTIFACT,
         definition__ids=[model.artifact_definition.definition_id],
         include=["object"],
         branch=model.source_branch,
     )
+
+    await artifact_definition.targets.fetch()
+    group = artifact_definition.targets.peer
+    await group.members.fetch()
+
     artifacts_by_member = {}
     for artifact in existing_artifacts:
         artifacts_by_member[artifact.object.peer.id] = artifact.id
@@ -907,6 +910,15 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
         context=context,
     )
 
+    # Needs to be fetched before fetching group members otherwise `object` relationship would override
+    # existing node in client store without the `name` attribute due to #521
+    existing_instances = await client.filters(
+        kind=InfrahubKind.GENERATORINSTANCE,
+        definition__ids=[model.generator_definition.definition_id],
+        include=["object"],
+        branch=model.source_branch,
+    )
+
     group = await client.get(
         kind=InfrahubKind.GENERICGROUP,
         prefetch_relationships=True,
@@ -916,12 +928,6 @@ async def request_generator_definition_check(model: RequestGeneratorDefinitionCh
     )
     await group.members.fetch()
 
-    existing_instances = await client.filters(
-        kind=InfrahubKind.GENERATORINSTANCE,
-        definition__ids=[model.generator_definition.definition_id],
-        include=["object"],
-        branch=model.source_branch,
-    )
     instance_by_member = {}
     for instance in existing_instances:
         instance_by_member[instance.object.peer.id] = instance.id

{infrahub_server-1.4.4 → infrahub_server-1.4.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "infrahub-server"
-version = "1.4.4"
+version = "1.4.6"
 description = "Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run."
 authors = ["OpsMill <info@opsmill.com>"]
 readme = "README.md"
@@ -94,7 +94,7 @@ ruff = "0.11.9"
 invoke = "2.2.0"
 pytest-benchmark = "^4.0.0"
 pytest-codspeed = "^2.2.0"
-deepdiff = "^6.2"
+deepdiff = "8.6.1"
 polyfactory = "^2.16.2"
 towncrier = "^24.8"
 pytest-env = "^1.1.3"