infrahub-server 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

infrahub/core/migrations/graph/m018_uniqueness_nulls.py

@@ -21,81 +21,79 @@ if TYPE_CHECKING:
 log = get_logger()
 
 
+async def validate_nulls_in_uniqueness_constraints(db: InfrahubDatabase) -> MigrationResult:
+    """
+    Validate any schema that include optional attributes in the uniqueness constraints
+
+    An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
+    """
+
+    default_branch = registry.get_branch_from_registry()
+    build_component_registry()
+    component_registry = get_component_registry()
+    uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
+    non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
+
+    manager = SchemaManager()
+    registry.schema = manager
+    internal_schema_root = SchemaRoot(**internal_schema)
+    manager.register_schema(schema=internal_schema_root)
+    schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
+    manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
+
+    for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
+        schema = schema_branch.get(name=schema_kind, duplicate=False)
+        if not isinstance(schema, NodeSchema | GenericSchema):
+            continue
+
+        uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+        includes_optional_attr: bool = False
+
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
+            for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
+                if schema_attribute_path.attribute_schema and schema_attribute_path.attribute_schema.optional is True:
+                    includes_optional_attr = True
+                    break
+
+        if not includes_optional_attr:
+            continue
+
+        non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
+        if non_unique_nodes:
+            non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
+
+    if not non_unique_nodes_by_kind:
+        return MigrationResult()
+
+    error_strings = []
+    for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
+        display_label_map = await get_display_labels_per_kind(
+            db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
+        )
+        for non_unique_node in non_unique_nodes:
+            display_label = display_label_map.get(non_unique_node.node_id)
+            error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
+            error_str += " violates uniqueness constraints for the following attributes: "
+            attr_values = [
+                f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
+            ]
+            error_str += ", ".join(attr_values)
+            error_strings.append(error_str)
+    if error_strings:
+        error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
+        error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
+        error_str += " now that NULL values are considered during uniqueness validation"
+        return MigrationResult(errors=[error_str] + error_strings)
+    return MigrationResult()
+
+
 class Migration018(InternalSchemaMigration):
     name: str = "018_validate_nulls_in_uniqueness_constraints"
     minimum_version: int = 17
     migrations: Sequence[SchemaMigration] = []
 
     async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
-        result = MigrationResult()
-
-        return result
+        return MigrationResult()
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
-        """
-        Validate any schema that include optional attributes in the uniqueness constraints
-
-        An update to uniqueness constraint validation now handles NULL values as unique instead of ignoring them
-        """
-        default_branch = registry.get_branch_from_registry()
-        build_component_registry()
-        component_registry = get_component_registry()
-        uniqueness_checker = await component_registry.get_component(UniquenessChecker, db=db, branch=default_branch)
-        non_unique_nodes_by_kind: dict[str, list[NonUniqueNode]] = defaultdict(list)
-
-        manager = SchemaManager()
-        registry.schema = manager
-        internal_schema_root = SchemaRoot(**internal_schema)
-        manager.register_schema(schema=internal_schema_root)
-        schema_branch = await manager.load_schema_from_db(db=db, branch=default_branch)
-        manager.set_schema_branch(name=default_branch.name, schema=schema_branch)
-
-        for schema_kind in schema_branch.node_names + schema_branch.generic_names_without_templates:
-            schema = schema_branch.get(name=schema_kind, duplicate=False)
-            if not isinstance(schema, NodeSchema | GenericSchema):
-                continue
-
-            uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(
-                schema_branch=schema_branch
-            )
-            includes_optional_attr: bool = False
-
-            for uniqueness_constraint_path in uniqueness_constraint_paths:
-                for schema_attribute_path in uniqueness_constraint_path.attributes_paths:
-                    if (
-                        schema_attribute_path.attribute_schema
-                        and schema_attribute_path.attribute_schema.optional is True
-                    ):
-                        includes_optional_attr = True
-                        break
-
-            if not includes_optional_attr:
-                continue
-
-            non_unique_nodes = await uniqueness_checker.check_one_schema(schema=schema)
-            if non_unique_nodes:
-                non_unique_nodes_by_kind[schema_kind] = non_unique_nodes
-
-        if not non_unique_nodes_by_kind:
-            return MigrationResult()
-
-        error_strings = []
-        for schema_kind, non_unique_nodes in non_unique_nodes_by_kind.items():
-            display_label_map = await get_display_labels_per_kind(
-                db=db, kind=schema_kind, branch_name=default_branch.name, ids=[nun.node_id for nun in non_unique_nodes]
-            )
-            for non_unique_node in non_unique_nodes:
-                display_label = display_label_map.get(non_unique_node.node_id)
-                error_str = f"{display_label or ''}({non_unique_node.node_schema.kind} / {non_unique_node.node_id})"
-                error_str += " violates uniqueness constraints for the following attributes: "
-                attr_values = [
-                    f"{attr.attribute_name}={attr.attribute_value}" for attr in non_unique_node.non_unique_attributes
-                ]
-                error_str += ", ".join(attr_values)
-                error_strings.append(error_str)
-        if error_strings:
-            error_str = "For the following nodes, you must update the uniqueness_constraints on the schema of the node"
-            error_str += " to remove the attribute(s) with NULL values or update the data on the nodes to be unique"
-            error_str += " now that NULL values are considered during uniqueness validation"
-            return MigrationResult(errors=[error_str] + error_strings)
-        return MigrationResult()
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m025_uniqueness_nulls.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.log import get_logger
+
+from ..shared import InternalSchemaMigration, SchemaMigration
+from .m018_uniqueness_nulls import validate_nulls_in_uniqueness_constraints
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration025(InternalSchemaMigration):
+    name: str = "025_validate_nulls_in_uniqueness_constraints"
+    minimum_version: int = 24
+    migrations: Sequence[SchemaMigration] = []
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        return await validate_nulls_in_uniqueness_constraints(db=db)

infrahub/core/migrations/graph/m026_0000_prefix_fix.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import ipaddress
+from typing import TYPE_CHECKING, Sequence
+
+from infrahub.core.branch.models import Branch
+from infrahub.core.initialization import initialization
+from infrahub.core.ipam.reconciler import IpamReconciler
+from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.timestamp import Timestamp
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ..shared import InternalSchemaMigration, SchemaMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class Migration026(InternalSchemaMigration):
+    name: str = "026_prefix_0000_fix"
+    minimum_version: int = 25
+    migrations: Sequence[SchemaMigration] = []
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        return MigrationResult()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+
+        at = Timestamp()
+        for branch in await Branch.get_list(db=db):
+            prefix_0000s = await NodeManager.query(
+                db=db, schema="BuiltinIPPrefix", branch=branch, filters={"prefix__values": ["0.0.0.0/0", "::/0"]}
+            )
+            if not prefix_0000s:
+                continue
+            ipam_reconciler = IpamReconciler(db=db, branch=branch)
+            for prefix in prefix_0000s:
+                ip_namespace = await prefix.ip_namespace.get_peer(db=db)
+                ip_network = ipaddress.ip_network(prefix.prefix.value)
+                await ipam_reconciler.reconcile(
+                    ip_value=ip_network,
+                    namespace=ip_namespace,
+                    node_uuid=prefix.get_id(),
+                    at=at,
+                )
+
+        return MigrationResult()

infrahub/core/migrations/schema/node_attribute_remove.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Sequence
 
 from infrahub.core.constants import RelationshipStatus
 from infrahub.core.graph.schema import GraphAttributeRelationships
+from infrahub.core.schema.generic_schema import GenericSchema
 
 from ..query import AttributeMigrationQuery
 from ..shared import AttributeSchemaMigration
@@ -22,8 +23,20 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
 
+        attr_name = self.migration.schema_path.field_name
+        kinds_to_ignore = []
+        if isinstance(self.migration.new_node_schema, GenericSchema) and attr_name is not None:
+            for inheriting_schema_kind in self.migration.new_node_schema.used_by:
+                node_schema = db.schema.get_node_schema(
+                    name=inheriting_schema_kind, branch=self.branch, duplicate=False
+                )
+                attr_schema = node_schema.get_attribute_or_none(name=attr_name)
+                if attr_schema and not attr_schema.inherited:
+                    kinds_to_ignore.append(inheriting_schema_kind)
+
         self.params["node_kind"] = self.migration.new_schema.kind
-        self.params["attr_name"] = self.migration.schema_path.field_name
+        self.params["kinds_to_ignore"] = kinds_to_ignore
+        self.params["attr_name"] = attr_name
         self.params["current_time"] = self.at.to_string()
         self.params["branch_name"] = self.branch.name
         self.params["branch_support"] = self.migration.previous_attribute_schema.get_branch().value
@@ -60,7 +73,8 @@ class NodeAttributeRemoveMigrationQuery01(AttributeMigrationQuery):
         query = """
         // Find all the active nodes
         MATCH (node:%(node_kind)s)
-        WHERE exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
+        WHERE (size($kinds_to_ignore) = 0 OR NOT any(l IN labels(node) WHERE l IN $kinds_to_ignore))
+        AND exists((node)-[:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name }))
         CALL {
             WITH node
             MATCH (root:Root)<-[r:IS_PART_OF]-(node)

infrahub/core/models.py

@@ -529,7 +529,7 @@ class HashableModel(BaseModel):
 
         return new_list
 
-    def update(self, other: Self) -> Self:
+    def update(self, other: HashableModel) -> Self:
         """Update the current object with the new value from the new one if they are defined.
 
         Currently this method works for the following type of fields

infrahub/core/node/__init__.py

@@ -259,7 +259,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             )
             return
 
-        if number_pool.node.value == self._schema.kind and number_pool.node_attribute.value == attribute.name:
+        if (
+            number_pool.node.value in [self._schema.kind] + self._schema.inherit_from
+            and number_pool.node_attribute.value == attribute.name
+        ):
             try:
                 next_free = await number_pool.get_resource(db=db, branch=self._branch, node=self)
             except PoolExhaustedError:

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -220,8 +220,13 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
 
         violations = []
         for schema in schemas_to_check:
+            schema_filters = list(filters) if filters is not None else []
+            for attr_schema in schema.attributes:
+                if attr_schema.optional and attr_schema.unique and attr_schema.name not in schema_filters:
+                    schema_filters.append(attr_schema.name)
+
             schema_violations = await self._get_single_schema_violations(
-                node=node, node_schema=schema, at=at, filters=filters
+                node=node, node_schema=schema, at=at, filters=schema_filters
             )
             violations.extend(schema_violations)
 

infrahub/core/node/resource_manager/number_pool.py

@@ -50,7 +50,7 @@ class CoreNumberPool(Node):
             taken=taken,
         )
         if next_number is None:
-            raise PoolExhaustedError("There are no more addresses available in this pool.")
+            raise PoolExhaustedError("There are no more values available in this pool.")
 
         return next_number
 

infrahub/core/registry.py

@@ -220,5 +220,23 @@ class Registry:
             and branch.active_schema_hash.main != default_branch.active_schema_hash.main
         ]
 
+    async def purge_inactive_branches(
+        self, db: InfrahubDatabase, active_branches: list[Branch] | None = None
+    ) -> list[str]:
+        """Return a list of branches that were purged from the registry."""
+        active_branches = active_branches or await self.branch_object.get_list(db=db)
+        active_branch_names = [branch.name for branch in active_branches]
+        purged_branches: set[str] = set()
+
+        for branch_name in list(registry.branch.keys()):
+            if branch_name not in active_branch_names:
+                del registry.branch[branch_name]
+                purged_branches.add(branch_name)
+
+        purged_branches.update(self.schema.purge_inactive_branches(active_branches=active_branch_names))
+        purged_branches.update(db.purge_inactive_schemas(active_branches=active_branch_names))
+
+        return sorted(purged_branches)
+
 
 registry = Registry()

infrahub/core/schema/basenode_schema.py

@@ -11,7 +11,7 @@ from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
 
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
-from infrahub.core.models import HashableModelDiff
+from infrahub.core.models import HashableModel, HashableModelDiff
 
 from .attribute_schema import AttributeSchema
 from .generated.base_node_schema import GeneratedBaseNodeSchema
@@ -27,6 +27,16 @@ if TYPE_CHECKING:
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
 INHERITED = "INHERITED"
 
+OPTIONAL_TEXT_FIELDS = [
+    "default_filter",
+    "description",
+    "label",
+    "menu_placement",
+    "documentation",
+    "parent",
+    "children",
+]
+
 
 class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
@@ -480,6 +490,16 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             return UniquenessConstraintType.SUBSET_OF_HFID
         return UniquenessConstraintType.STANDARD
 
+    def update(self, other: HashableModel) -> Self:
+        super().update(other=other)
+
+        # Allow to specify empty string to remove existing fields values
+        for field_name in OPTIONAL_TEXT_FIELDS:
+            if getattr(other, field_name, None) == "":  # noqa: PLC1901
+                setattr(self, field_name, None)
+
+        return self
+
 
 @dataclass
 class SchemaUniquenessConstraintPath:

infrahub/core/schema/definitions/internal.py

@@ -18,6 +18,7 @@ from infrahub.core.constants import (
     DEFAULT_NAME_MIN_LENGTH,
     DEFAULT_REL_IDENTIFIER_LENGTH,
     NAME_REGEX,
+    NAME_REGEX_OR_EMPTY,
     NAMESPACE_REGEX,
     NODE_KIND_REGEX,
     NODE_NAME_REGEX,
@@ -269,7 +270,7 @@ base_node_schema = SchemaNode(
         SchemaAttribute(
             name="default_filter",
             kind="Text",
-            regex=str(NAME_REGEX),
+            regex=str(NAME_REGEX_OR_EMPTY),
             description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
             optional=True,
             extra={"update": UpdateSupport.ALLOWED},

infrahub/core/schema/generated/base_node_schema.py

@@ -50,7 +50,7 @@ class GeneratedBaseNodeSchema(HashableModel):
     default_filter: str | None = Field(
         default=None,
         description="Default filter used to search for a node in addition to its ID. (deprecated: please use human_friendly_id instead)",
-        pattern=r"^[a-z0-9\_]+$",
+        pattern=r"^[a-z0-9\_]*$",
         json_schema_extra={"update": "allowed"},
     )
     human_friendly_id: list[str] | None = Field(

infrahub/core/schema/manager.py

@@ -155,7 +155,6 @@ class SchemaManager(NodeManager):
 
         updated_schema = None
         if update_db:
-            schema_diff = None
             if diff:
                 schema_diff = await self.update_schema_to_db(schema=schema, db=db, branch=branch, diff=diff)
             else:
@@ -744,3 +743,24 @@ class SchemaManager(NodeManager):
         """Convert a schema_node object loaded from the database into GenericSchema object."""
         node_data = await cls._prepare_node_data(schema_node=schema_node, db=db)
         return GenericSchema(**node_data)
+
+    def purge_inactive_branches(self, active_branches: list[str]) -> list[str]:
+        """Return non active branches that were purged."""
+
+        hashes_to_keep: set[str] = set()
+        for active_branch in active_branches:
+            if branch := self._branches.get(active_branch):
+                nodes = branch.get_all(include_internal=True, duplicate=False)
+                hashes_to_keep.update([node.get_hash() for node in nodes.values()])
+
+        removed_branches: list[str] = []
+        for branch_name in list(self._branches.keys()):
+            if branch_name not in active_branches:
+                del self._branches[branch_name]
+                removed_branches.append(branch_name)
+
+        for hash_key in list(self._cache.keys()):
+            if hash_key not in hashes_to_keep:
+                del self._cache[hash_key]
+
+        return removed_branches

infrahub/core/schema/schema_branch.py

@@ -1005,9 +1005,11 @@ class SchemaBranch:
             generic_schema = self.get_generic(name=name, duplicate=False)
             for attribute in generic_schema.attributes:
                 if attribute.computed_attribute and attribute.computed_attribute.kind != ComputedAttributeKind.USER:
-                    raise ValueError(
-                        f"{generic_schema.kind}: Attribute {attribute.name!r} computed attributes are only allowed on nodes not generics"
-                    )
+                    for inheriting_node in generic_schema.used_by:
+                        node_schema = self.get_node(name=inheriting_node, duplicate=False)
+                        self.computed_attributes.validate_generic_inheritance(
+                            node=node_schema, attribute=attribute, generic=generic_schema
+                        )
 
     def _validate_computed_attribute(self, node: NodeSchema, attribute: AttributeSchema) -> None:
         if not attribute.computed_attribute or attribute.computed_attribute.kind == ComputedAttributeKind.USER:
@@ -1955,10 +1957,9 @@ class SchemaBranch:
                 )
             )
 
-            if relationship.kind == RelationshipKind.PARENT:
-                template_schema.human_friendly_id = [
-                    f"{relationship.name}__template_name__value"
-                ] + template_schema.human_friendly_id
+            parent_hfid = f"{relationship.name}__template_name__value"
+            if relationship.kind == RelationshipKind.PARENT and parent_hfid not in template_schema.human_friendly_id:
+                template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
     def generate_object_template_from_node(

infrahub/core/schema/schema_branch_computed.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.schema import AttributeSchema  # noqa: TC001
 
 if TYPE_CHECKING:
-    from infrahub.core.schema import NodeSchema, SchemaAttributePath
+    from infrahub.core.schema import GenericSchema, NodeSchema, SchemaAttributePath
 
 
 @dataclass
@@ -90,6 +90,7 @@ class ComputedAttributes:
     ) -> None:
         self._computed_python_transform_attribute_map: dict[str, list[AttributeSchema]] = transform_attribute_map or {}
         self._computed_jinja2_attribute_map: dict[str, RegisteredNodeComputedAttribute] = jinja2_attribute_map or {}
+        self._defined_from_generic: dict[str, str] = {}
 
     def duplicate(self) -> ComputedAttributes:
         return self.__class__(
@@ -166,6 +167,16 @@ class ComputedAttributes:
                 schema_path.active_relationship_schema.name
             ].append(deepcopy(source_attribute))
 
+    def validate_generic_inheritance(
+        self, node: NodeSchema, attribute: AttributeSchema, generic: GenericSchema
+    ) -> None:
+        attribute_key = f"{node.kind}__{attribute.name}"
+        if duplicate := self._defined_from_generic.get(attribute_key):
+            raise ValueError(
+                f"{node.kind}: {attribute.name!r} is declared as a computed attribute from multiple generics {sorted([duplicate, generic.kind])}"
+            )
+        self._defined_from_generic[attribute_key] = generic.kind
+
     def get_impacted_jinja2_targets(self, kind: str, updates: list[str] | None = None) -> list[ComputedAttributeTarget]:
         if mapping := self._computed_jinja2_attribute_map.get(kind):
             return mapping.get_targets(updates=updates)

infrahub/database/__init__.py

@@ -205,6 +205,16 @@ class InfrahubDatabase:
     def add_schema(self, schema: SchemaBranch, name: str | None = None) -> None:
         self._schemas[name or schema.name] = schema
 
+    def purge_inactive_schemas(self, active_branches: list[str]) -> list[str]:
+        """Return non active schema branches that were purged."""
+        removed_branches: list[str] = []
+        for branch_name in list(self._schemas.keys()):
+            if branch_name not in active_branches:
+                del self._schemas[branch_name]
+                removed_branches.append(branch_name)
+
+        return removed_branches
+
     def start_session(self, read_only: bool = False, schemas: list[SchemaBranch] | None = None) -> InfrahubDatabase:
         """Create a new InfrahubDatabase object in Session mode."""
         session_mode = InfrahubDatabaseSessionMode.WRITE

infrahub/events/branch_action.py

@@ -100,6 +100,9 @@ class BranchMergedEvent(InfrahubEvent):
 
         return related
 
+    def get_messages(self) -> list[InfrahubMessage]:
+        return [RefreshRegistryBranches()]
+
 
 class BranchRebasedEvent(InfrahubEvent):
     """Event generated when a branch has been rebased"""

infrahub/events/group_action.py

@@ -2,7 +2,7 @@ from typing import ClassVar
 
 from pydantic import Field
 
-from infrahub.core.constants import MutationAction
+from infrahub.core.constants import InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import EventNode, InfrahubEvent
@@ -21,6 +21,11 @@ class GroupMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         related.append(
             {
                 "prefect.resource.id": self.node_id,

infrahub/events/node_action.py

@@ -7,7 +7,7 @@ from infrahub.core.changelog.models import (
     RelationshipCardinalityManyChangelog,
     RelationshipCardinalityOneChangelog,
 )
-from infrahub.core.constants import DiffAction, MutationAction
+from infrahub.core.constants import DiffAction, InfrahubKind, MutationAction
 
 from .constants import EVENT_NAMESPACE
 from .models import InfrahubEvent
@@ -24,6 +24,10 @@ class NodeMutatedEvent(InfrahubEvent):
 
     def get_related(self) -> list[dict[str, str]]:
         related = super().get_related()
+        if self.kind in [InfrahubKind.GENERATORGROUP, InfrahubKind.GRAPHQLQUERYGROUP]:
+            # Temporary workaround to avoid too large payloads for the related field
+            return related
+
         for attribute in self.changelog.attributes.values():
             related.append(
                 {

infrahub/git/integrator.py

@@ -954,7 +954,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             source=self.id,
             is_protected=True,
         )
-        obj = await self.sdk.create(kind=CoreCheckDefinition, branch=branch_name, **create_payload)
+        obj = await self.sdk.create(kind=CoreCheckDefinition, branch=branch_name, data=create_payload)
         await obj.save()
 
         return obj
@@ -1012,7 +1012,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             source=str(self.id),
             is_protected=True,
         )
-        obj = await self.sdk.create(kind=CoreTransformPython, branch=branch_name, **create_payload)
+        obj = await self.sdk.create(kind=CoreTransformPython, branch=branch_name, data=create_payload)
         await obj.save()
         return obj