infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub/core/node/create.py

@@ -2,18 +2,23 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
-from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
+from infrahub.core.node.lock_utils import get_lock_names_on_object_mutation
 from infrahub.core.protocols import CoreObjectTemplate
+from infrahub.core.schema import GenericSchema
 from infrahub.dependencies.registry import get_component_registry
+from infrahub.lock import InfrahubMultiLock
+from infrahub.profiles.node_applier import NodeProfilesApplier
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.relationship.model import RelationshipManager
     from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes, RelationshipSchema
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -87,6 +92,7 @@ async def handle_template_relationships(
     template: CoreObjectTemplate,
     fields: list,
     constraint_runner: NodeConstraintRunner | None = None,
+    at: Timestamp | None = None,
 ) -> None:
     if constraint_runner is None:
         component_registry = get_component_registry()
@@ -114,7 +120,7 @@ async def handle_template_relationships(
                 current_template=template,
             )
 
-            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch)
+            obj_peer = await Node.init(schema=obj_peer_schema, db=db, branch=branch, at=at)
             await obj_peer.new(db=db, **obj_peer_data)
             await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
             await obj_peer.save(db=db)
@@ -126,6 +132,7 @@ async def handle_template_relationships(
                 obj=obj_peer,
                 template=template_relationship_peer,
                 fields=fields,
+                at=at,
             )
 
 
@@ -136,43 +143,20 @@ async def get_profile_ids(db: InfrahubDatabase, obj: Node) -> set[str]:
     return {pr.peer_id for pr in profile_rels}
 
 
-async def refresh_for_profile_update(
-    db: InfrahubDatabase,
-    branch: Branch,
-    obj: Node,
-    schema: NonGenericSchemaTypes,
-    previous_profile_ids: set[str] | None = None,
-) -> Node:
-    if not hasattr(obj, "profiles"):
-        return obj
-    current_profile_ids = await get_profile_ids(db=db, obj=obj)
-    if previous_profile_ids is None or previous_profile_ids != current_profile_ids:
-        refreshed_node = await NodeManager.get_one_by_id_or_default_filter(
-            db=db,
-            kind=schema.kind,
-            id=obj.get_id(),
-            branch=branch,
-            include_owner=True,
-            include_source=True,
-        )
-        refreshed_node._node_changelog = obj.node_changelog
-        return refreshed_node
-    return obj
-
-
 async def _do_create_node(
     node_class: type[Node],
+    node_constraint_runner: NodeConstraintRunner,
     db: InfrahubDatabase,
-    data: dict,
     schema: NonGenericSchemaTypes,
-    fields_to_validate: list,
     branch: Branch,
-    node_constraint_runner: NodeConstraintRunner,
+    fields_to_validate: list[str],
+    data: dict[str, Any],
+    at: Timestamp | None = None,
 ) -> Node:
     obj = await node_class.init(db=db, schema=schema, branch=branch)
     await obj.new(db=db, **data)
     await node_constraint_runner.check(node=obj, field_filters=fields_to_validate)
-    await obj.save(db=db)
+    await obj.save(db=db, at=at)
 
     object_template = await obj.get_object_template(db=db)
     if object_template:
@@ -182,50 +166,70 @@ async def _do_create_node(
             template=object_template,
             obj=obj,
             fields=fields_to_validate,
+            at=at,
         )
     return obj
 
 
 async def create_node(
-    data: dict,
+    data: dict[str, Any],
     db: InfrahubDatabase,
     branch: Branch,
-    schema: NonGenericSchemaTypes,
+    schema: MainSchemaTypes,
+    at: Timestamp | None = None,
 ) -> Node:
     """Create a node in the database if constraint checks succeed."""
 
+    if isinstance(schema, GenericSchema):
+        raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
+
     component_registry = get_component_registry()
-    node_constraint_runner = await component_registry.get_component(
-        NodeConstraintRunner, db=db.start_session() if not db.is_transaction else db, branch=branch
-    )
     node_class = Node
     if schema.kind in registry.node:
         node_class = registry.node[schema.kind]
 
     fields_to_validate = list(data)
-    if db.is_transaction:
-        obj = await _do_create_node(
-            node_class=node_class,
-            node_constraint_runner=node_constraint_runner,
-            db=db,
-            schema=schema,
-            branch=branch,
-            fields_to_validate=fields_to_validate,
-            data=data,
-        )
-    else:
-        async with db.start_transaction() as dbt:
+
+    preview_obj = await node_class.init(db=db, schema=schema, branch=branch)
+    await preview_obj.new(db=db, process_pools=False, **data)
+    schema_branch = db.schema.get_schema_branch(name=branch.name)
+    lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+    obj: Node
+    async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+        if db.is_transaction:
+            node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
+
             obj = await _do_create_node(
                 node_class=node_class,
                 node_constraint_runner=node_constraint_runner,
-                db=dbt,
+                db=db,
                 schema=schema,
                 branch=branch,
                 fields_to_validate=fields_to_validate,
                 data=data,
+                at=at,
             )
+        else:
+            async with db.start_transaction() as dbt:
+                node_constraint_runner = await component_registry.get_component(
+                    NodeConstraintRunner, db=dbt, branch=branch
+                )
+
+                obj = await _do_create_node(
+                    node_class=node_class,
+                    node_constraint_runner=node_constraint_runner,
+                    db=dbt,
+                    schema=schema,
+                    branch=branch,
+                    fields_to_validate=fields_to_validate,
+                    data=data,
+                    at=at,
+                )
 
     if await get_profile_ids(db=db, obj=obj):
-        obj = await refresh_for_profile_update(db=db, branch=branch, schema=schema, obj=obj)
+        node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
+        await node_profiles_applier.apply_profiles(node=obj)
+        await obj.save(db=db)
 
     return obj

infrahub/core/node/lock_utils.py

@@ -0,0 +1,124 @@
+import hashlib
+from typing import TYPE_CHECKING
+
+from infrahub.core.node import Node
+from infrahub.core.schema import GenericSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
+
+if TYPE_CHECKING:
+    from infrahub.core.relationship import RelationshipManager
+
+
+RESOURCE_POOL_LOCK_NAMESPACE = "resource_pool"
+
+
+def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
+    """
+    Return kinds for which we want to lock during creating / updating an object of a given schema node.
+    Lock should be performed on schema kind and its generics having a uniqueness_constraint defined.
+    If a generic uniqueness constraint is the same as the node schema one,
+    it means node schema overrided this constraint, in which case we only need to lock on the generic.
+    """
+
+    node_schema = schema_branch.get(name=kind, duplicate=False)
+
+    schema_uc = None
+    kinds = []
+    if node_schema.uniqueness_constraints:
+        kinds.append(node_schema.kind)
+        schema_uc = node_schema.uniqueness_constraints
+
+    if isinstance(node_schema, GenericSchema):
+        return kinds
+
+    generics_kinds = node_schema.inherit_from
+
+    node_schema_kind_removed = False
+    for generic_kind in generics_kinds:
+        generic_uc = schema_branch.get(name=generic_kind, duplicate=False).uniqueness_constraints
+        if generic_uc:
+            kinds.append(generic_kind)
+            if not node_schema_kind_removed and generic_uc == schema_uc:
+                # Check whether we should remove original schema kind as it simply overrides uniqueness_constraint
+                # of a generic
+                kinds.pop(0)
+                node_schema_kind_removed = True
+    return kinds
+
+
+def _hash(value: str) -> str:
+    # Do not use builtin `hash` for lock names as due to randomization results would differ between
+    # different processes.
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+def get_lock_names_on_object_mutation(node: Node, schema_branch: SchemaBranch) -> list[str]:
+    """
+    Return lock names for object on which we want to avoid concurrent mutation (create/update).
+    Lock names include kind, some generic kinds, resource pool ids, and values of attributes of corresponding uniqueness constraints.
+    """
+
+    lock_names: set[str] = set()
+
+    # Check if node is using resource manager allocation via attributes
+    for attr_name in node.get_schema().attribute_names:
+        attribute = getattr(node, attr_name, None)
+        if attribute is not None and getattr(attribute, "from_pool", None) and "id" in attribute.from_pool:
+            lock_names.add(f"{RESOURCE_POOL_LOCK_NAMESPACE}.{attribute.from_pool['id']}")
+
+    # Check if relationships allocate resources
+    for rel_name in node._relationships:
+        rel_manager: RelationshipManager = getattr(node, rel_name)
+        for rel in rel_manager._relationships:
+            if rel.from_pool and "id" in rel.from_pool:
+                lock_names.add(f"{RESOURCE_POOL_LOCK_NAMESPACE}.{rel.from_pool['id']}")
+
+    lock_kinds = _get_kinds_to_lock_on_object_mutation(node.get_kind(), schema_branch)
+    for kind in lock_kinds:
+        schema = schema_branch.get(name=kind, duplicate=False)
+        ucs = schema.uniqueness_constraints
+        if ucs is None:
+            continue
+
+        ucs_lock_names: list[str] = []
+        uc_attributes_names = set()
+
+        for uc in ucs:
+            uc_attributes_values = []
+            # Keep only attributes constraints
+            for field_path in uc:
+                # Some attributes may exist in different uniqueness constraints, we de-duplicate them
+                if field_path in uc_attributes_names:
+                    continue
+
+                # Exclude relationships uniqueness constraints
+                schema_path = schema.parse_schema_path(path=field_path, schema=schema_branch)
+                if schema_path.related_schema is not None or schema_path.attribute_schema is None:
+                    continue
+
+                uc_attributes_names.add(field_path)
+                attr = getattr(node, schema_path.attribute_schema.name, None)
+                if attr is None or attr.value is None:
+                    # `attr.value` being None corresponds to optional unique attribute.
+                    # `attr` being None is not supposed to happen.
+                    value_hashed = _hash("")
+                else:
+                    value_hashed = _hash(str(attr.value))
+
+                uc_attributes_values.append(value_hashed)
+
+            if uc_attributes_values:
+                uc_lock_name = ".".join(uc_attributes_values)
+                ucs_lock_names.append(uc_lock_name)
+
+        if not ucs_lock_names:
+            continue
+
+        partial_lock_name = kind + "." + ".".join(ucs_lock_names)
+        lock_names.add(build_object_lock_name(partial_lock_name))
+
+    return sorted(lock_names)
+
+
+def build_object_lock_name(name: str) -> str:
+    return f"global.object.{name}"

infrahub/core/node/node_property_attribute.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from infrahub_sdk.template import Jinja2Template
+
+from infrahub.core.query.node import AttributeFromDB
+from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+
+from ..attribute import BaseAttribute, ListAttributeOptional, StringOptional
+
+if TYPE_CHECKING:
+    from infrahub.core.node import Node
+    from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+    from infrahub.core.schema.attribute_schema import AttributeSchema
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+T = TypeVar("T")
+
+
+class NodePropertyAttribute(Generic[T]):
+    """A node property attribute is a construct that seats between a property and an attribute.
+
+    View it as a property, set at the node level but stored in the database as an attribute. It usually is something computed from other components of
+    a node, such as its attributes and its relationships.
+    """
+
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: T | None,
+        value: AttributeFromDB | T | None = None,
+    ) -> None:
+        self.node_schema = node_schema
+
+        self.node_attributes: list[str] = []
+        self.node_relationships: list[str] = []
+
+        self.template = template
+        self._value = value
+        self._manually_assigned = False
+
+        self.schema: AttributeSchema
+
+        self.analyze_variables()
+
+    def needs_update(self, fields: list[str] | None) -> bool:
+        """Tell if this node property attribute must be recomputed given a list of updated fields of a node."""
+        if self._manually_assigned or not fields:
+            return True
+        for field in fields:
+            if field in self.node_attributes or field in self.node_relationships:
+                return True
+
+        return False
+
+    @property
+    def attribute_value(self) -> AttributeFromDB | dict[str, T | None]:
+        if isinstance(self._value, AttributeFromDB):
+            return self._value
+        return {"value": self._value}
+
+    def set_value(self, value: T | None, manually_assigned: bool = False) -> None:
+        """Force the value of the node property attribute to the given one."""
+        if isinstance(self._value, AttributeFromDB):
+            self._value.value = value
+        else:
+            self._value = value
+
+        if manually_assigned:
+            self._manually_assigned = True
+
+    def get_value(self, node: Node, at: Timestamp) -> T | None:
+        if isinstance(self._value, AttributeFromDB):
+            attr = self.get_node_attribute(node=node, at=at)
+            return attr.value  # type: ignore
+
+        return self._value
+
+    @abstractmethod
+    def analyze_variables(self) -> None: ...
+
+    @abstractmethod
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None: ...
+
+    @abstractmethod
+    def get_node_attribute(self, node: Node, at: Timestamp) -> BaseAttribute: ...
+
+
+class DisplayLabel(NodePropertyAttribute[str]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: str | None,
+        value: AttributeFromDB | str | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="display_label")
+
+    @property
+    def is_jinja2_template(self) -> bool:
+        if self.template is None:
+            return False
+
+        return any(c in self.template for c in "{}")
+
+    def _analyze_plain_value(self) -> None:
+        if self.template is None or "__" not in self.template:
+            return
+
+        items = self.template.split("__", maxsplit=1)
+        if items[0] not in self.node_schema.attribute_names:
+            raise ValueError(f"{items[0]} is not an attribute of {self.node_schema.kind}")
+
+        self.node_attributes.append(items[0])
+
+    def _analyze_jinja2_value(self) -> None:
+        if self.template is None or not self.is_jinja2_template:
+            return
+
+        tpl = Jinja2Template(template=self.template)
+        for variable in tpl.get_variables():
+            items = variable.split("__", maxsplit=1)
+            if items[0] in self.node_schema.attribute_names:
+                self.node_attributes.append(items[0])
+            elif items[0] in self.node_schema.relationship_names:
+                self.node_relationships.append(items[0])
+            else:
+                raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the display label and record attributes and relationships required to compute it."""
+        if not self.is_jinja2_template:
+            self._analyze_plain_value()
+        else:
+            self._analyze_jinja2_value()
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the display label value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"display_label for schema {self.node_schema.kind} cannot be rendered for node {node.get_schema().kind} {node.id}"
+            )
+
+        if not self.is_jinja2_template:
+            path_value = await node.get_path_value(db=db, path=self.template)
+            # Use .value for enum to keep compat with old style display label
+            self.set_value(value=str(path_value if not isinstance(path_value, Enum) else path_value.value))
+            return
+
+        jinja2_template = Jinja2Template(template=self.template)
+
+        variables: dict[str, Any] = {}
+        for variable in jinja2_template.get_variables():
+            variables[variable] = await node.get_path_value(db=db, path=variable)
+
+        self.set_value(value=await jinja2_template.render(variables=variables))
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> StringOptional:
+        """Return a node attribute that can be stored in the database for this display label and node."""
+        return StringOptional(
+            name="display_label",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )
+
+
+class HumanFriendlyIdentifier(NodePropertyAttribute[list[str]]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: list[str] | None,
+        value: AttributeFromDB | list[str] | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="human_friendly_id")
+
+    def _analyze_single_variable(self, value: str) -> None:
+        items = value.split("__", maxsplit=1)
+        if items[0] in self.node_schema.attribute_names:
+            self.node_attributes.append(items[0])
+        elif items[0] in self.node_schema.relationship_names:
+            self.node_relationships.append(items[0])
+        else:
+            raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the HFID and record attributes and relationships required to compute it."""
+        for item in self.template or []:
+            self._analyze_single_variable(value=item)
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the HFID value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"human_friendly_id for schema {self.node_schema.kind} cannot be computed for node {node.get_schema().kind} {node.id}"
+            )
+
+        value: list[str] = []
+        for path in self.template:
+            path_value = await node.get_path_value(db=db, path=path)
+            # Use .value for enum to be consistent with display label
+            value.append(path_value if not isinstance(path_value, Enum) else path_value.value)
+
+        self.set_value(value=value)
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> ListAttributeOptional:
+        """Return a node attribute that can be stored in the database for this HFID and node."""
+        return ListAttributeOptional(
+            name="human_friendly_id",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )

infrahub/core/node/resource_manager/ip_address_pool.py

@@ -15,6 +15,7 @@ from infrahub.exceptions import PoolExhaustedError, ValidationError
 from infrahub.pools.address import get_available
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -34,7 +35,7 @@ class CoreIPAddressPool(Node):
         prefixlen: int | None = None,
         at: Timestamp | None = None,
     ) -> Node:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # Check if there is already a resource allocated with this identifier
             # if not, pull all existing prefixes and allocated the next available
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -17,6 +17,7 @@ from infrahub.exceptions import ValidationError
 from infrahub.pools.prefix import get_next_available_prefix
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -37,7 +38,7 @@ class CoreIPPrefixPool(Node):
         prefix_type: str | None = None,
         at: Timestamp | None = None,
     ) -> Node:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # Check if there is already a resource allocated with this identifier
             # if not, pull all existing prefixes and allocated the next available
             if identifier:

infrahub/core/node/resource_manager/number_pool.py

@@ -9,6 +9,7 @@ from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.exceptions import PoolExhaustedError
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -63,7 +64,7 @@ class CoreNumberPool(Node):
         identifier: str | None = None,
         at: Timestamp | None = None,
     ) -> int:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # NOTE: ideally we should use the HFID as the identifier (if available)
             # one of the challenge with using the HFID is that it might change over time
             # so we need to ensure that the identifier is stable, or we need to handle the case where the identifier changes

infrahub/core/node/standard.py

@@ -111,7 +111,7 @@ class StandardNode(BaseModel):
         node = result.get("n")
 
         self.id = node.element_id
-        self.uuid = node["uuid"]
+        self.uuid = UUID(node["uuid"])
 
         return True
 

infrahub/core/property.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import Enum
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -26,6 +27,10 @@ class NodePropertyData(BaseModel):
     peer_id: str
 
 
+class ClearValue(Enum):
+    CLEAR = "clear"
+
+
 class FlagPropertyMixin:
     _flag_properties: list[str] = [v.value for v in FlagProperty]
 
@@ -51,6 +56,7 @@ class NodePropertyMixin:
         for node in self._node_properties:
             setattr(self, f"_{node}", None)
             setattr(self, f"{node}_id", None)
+            setattr(self, f"_clear_{node}", False)
 
         if not kwargs:
             return
@@ -79,12 +85,14 @@ class NodePropertyMixin:
 
     def clear_owner(self) -> None:
         self._set_node_property(name="owner", value=None)
+        self._clear_owner = True
 
     async def get_source(self, db: InfrahubDatabase) -> Node | None:
         return await self._get_node_property(name="source", db=db)
 
     def clear_source(self) -> None:
         self._set_node_property(name="source", value=None)
+        self._clear_source = True
 
     def set_source(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="source", value=value)
@@ -95,6 +103,9 @@ class NodePropertyMixin:
     def set_owner(self, value: str | Node | UUID) -> None:
         self._set_node_property(name="owner", value=value)
 
+    def is_clear(self, name: str) -> bool:
+        return getattr(self, f"_clear_{name}", False)
+
     def _get_node_property_from_cache(self, name: str) -> Node:
         """Return the node attribute if it's already present locally,
         Otherwise raise an exception

infrahub/core/protocols.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from .protocols_base import CoreNode
+from infrahub.core.protocols_base import CoreNode
 
 if TYPE_CHECKING:
     from enum import Enum
@@ -125,6 +125,7 @@ class CoreGenericRepository(CoreNode):
     queries: RelationshipManager
     checks: RelationshipManager
     generators: RelationshipManager
+    groups_objects: RelationshipManager
 
 
 class CoreGroup(CoreNode):
@@ -349,6 +350,10 @@ class CoreGeneratorAction(CoreAction):
     generator: RelationshipManager
 
 
+class CoreGeneratorAwareGroup(CoreGroup):
+    pass
+
+
 class CoreGeneratorCheck(CoreCheck):
     instance: String
 
@@ -360,6 +365,8 @@ class CoreGeneratorDefinition(CoreTaskTarget):
     file_path: String
     class_name: String
     convert_query_response: BooleanOptional
+    execute_in_proposed_change: BooleanOptional
+    execute_after_merge: BooleanOptional
     query: RelationshipManager
     repository: RelationshipManager
     targets: RelationshipManager