infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub/core/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import uuid
+from enum import Enum
 from typing import Any, TypeAlias
 
 from infrahub_sdk.utils import deep_merge_dict
@@ -44,6 +45,21 @@ class SchemaExtension(HashableModel):
     nodes: list[NodeExtensionSchema] = Field(default_factory=list)
 
 
+class SchemaWarningType(Enum):
+    DEPRECATION = "deprecation"
+
+
+class SchemaWarningKind(BaseModel):
+    kind: str = Field(..., description="The kind impacted by the warning")
+    field: str | None = Field(default=None, description="The attribute or relationship impacted by the warning")
+
+
+class SchemaWarning(BaseModel):
+    type: SchemaWarningType = Field(..., description="The type of warning")
+    kinds: list[SchemaWarningKind] = Field(default_factory=list, description="The kinds impacted by the warning")
+    message: str = Field(..., description="The message that describes the warning")
+
+
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
@@ -80,6 +96,46 @@ class SchemaRoot(BaseModel):
 
         return errors
 
+    def gather_warnings(self) -> list[SchemaWarning]:
+        models = self.nodes + self.generics
+        warnings: list[SchemaWarning] = []
+        for model in models:
+            if model.display_labels is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="display_labels are deprecated, use display_label instead",
+                    )
+                )
+            if model.default_filter is not None:
+                warnings.append(
+                    SchemaWarning(
+                        type=SchemaWarningType.DEPRECATION,
+                        kinds=[SchemaWarningKind(kind=model.kind)],
+                        message="default_filter is deprecated",
+                    )
+                )
+            for attribute in model.attributes:
+                if attribute.max_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'max_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+                if attribute.min_length is not None:
+                    warnings.append(
+                        SchemaWarning(
+                            type=SchemaWarningType.DEPRECATION,
+                            kinds=[SchemaWarningKind(kind=model.kind, field=attribute.name)],
+                            message="Use of 'min_length' on attributes is deprecated, use parameters instead",
+                        )
+                    )
+
+        return warnings
+
     def generate_uuid(self) -> None:
         """Generate UUID for all nodes, attributes & relationships
         Mainly useful during unit tests."""

infrahub/core/schema/attribute_schema.py

@@ -68,6 +68,10 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    @property
+    def support_profiles(self) -> bool:
+        return self.read_only is False and self.optional is True
+
     def get_id(self) -> str:
         if self.id is None:
             raise InitializationError("The attribute schema has not been saved yet and doesn't have an id")

infrahub/core/schema/definitions/internal.py

@@ -568,7 +568,7 @@ attribute_schema = SchemaNode(
             "Mainly relevant for internal object.",
             default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.ALLOWED},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="unique",
@@ -585,7 +585,7 @@ attribute_schema = SchemaNode(
             default_value=False,
             override_default_value=False,
             optional=True,
-            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            extra={"update": UpdateSupport.MIGRATION_REQUIRED},
         ),
         SchemaAttribute(
             name="branch",

infrahub/core/schema/generated/attribute_schema.py

@@ -78,7 +78,7 @@ class GeneratedAttributeSchema(HashableModel):
     read_only: bool = Field(
         default=False,
         description="Set the attribute as Read-Only, users won't be able to change its value. Mainly relevant for internal object.",
-        json_schema_extra={"update": "allowed"},
+        json_schema_extra={"update": "migration_required"},
     )
     unique: bool = Field(
         default=False,
@@ -88,7 +88,7 @@ class GeneratedAttributeSchema(HashableModel):
     optional: bool = Field(
         default=False,
         description="Indicate if this attribute is mandatory or optional.",
-        json_schema_extra={"update": "validate_constraint"},
+        json_schema_extra={"update": "migration_required"},
     )
     branch: BranchSupportType | None = Field(
         default=None,

infrahub/core/schema/manager.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from cachetools import LRUCache
+from infrahub_sdk.schema import BranchSchema as SDKBranchSchema
+
 from infrahub import lock
 from infrahub.core.manager import NodeManager
 from infrahub.core.models import (
@@ -40,6 +43,8 @@ class SchemaManager(NodeManager):
     def __init__(self) -> None:
         self._cache: dict[int, Any] = {}
         self._branches: dict[str, SchemaBranch] = {}
+        self._branch_hash_by_name: dict[str, str] = {}
+        self._sdk_branches: LRUCache[str, SDKBranchSchema] = LRUCache(maxsize=10)
 
     def _get_from_cache(self, key: int) -> Any:
         return self._cache[key]
@@ -140,12 +145,26 @@ class SchemaManager(NodeManager):
         if name in self._branches:
             return self._branches[name]
 
-        self._branches[name] = SchemaBranch(cache=self._cache, name=name)
+        self.set_schema_branch(name, schema=SchemaBranch(cache=self._cache, name=name))
         return self._branches[name]
 
+    def get_sdk_schema_branch(self, name: str) -> SDKBranchSchema:
+        schema_hash = self._branch_hash_by_name[name]
+        branch_schema = self._sdk_branches.get(schema_hash)
+        if not branch_schema:
+            self._sdk_branches[schema_hash] = SDKBranchSchema.from_api_response(
+                data=self._branches[name].to_dict_api_schema_object()
+            )
+
+        return self._sdk_branches[schema_hash]
+
     def set_schema_branch(self, name: str, schema: SchemaBranch) -> None:
         schema.name = name
         self._branches[name] = schema
+        self._branch_hash_by_name[name] = schema.get_hash()
+
+    def has_schema_branch(self, name: str) -> bool:
+        return name in self._branches
 
     def process_schema_branch(self, name: str) -> None:
         schema_branch = self.get_schema_branch(name=name)
@@ -764,6 +783,8 @@ class SchemaManager(NodeManager):
         for branch_name in list(self._branches.keys()):
             if branch_name not in active_branches:
                 del self._branches[branch_name]
+                if branch_name in self._branch_hash_by_name:
+                    del self._branch_hash_by_name[branch_name]
                 removed_branches.append(branch_name)
 
         for hash_key in list(self._cache.keys()):

infrahub/core/schema/schema_branch.py

@@ -169,6 +169,14 @@ class SchemaBranch:
             "templates": {name: self.get(name, duplicate=duplicate) for name in self.templates},
         }
 
+    def to_dict_api_schema_object(self) -> dict[str, list[dict]]:
+        return {
+            "nodes": [self.get(name, duplicate=False).model_dump() for name in self.nodes],
+            "profiles": [self.get(name, duplicate=False).model_dump() for name in self.profiles],
+            "generics": [self.get(name, duplicate=False).model_dump() for name in self.generics],
+            "templates": [self.get(name, duplicate=False).model_dump() for name in self.templates],
+        }
+
     @classmethod
     def from_dict_schema_object(cls, data: dict) -> Self:
         type_mapping = {
@@ -320,14 +328,23 @@ class SchemaBranch:
         elif name in self.templates:
             key = self.templates[name]
 
-        if key and duplicate:
-            return self._cache[key].duplicate()
-        if key and not duplicate:
-            return self._cache[key]
+        if not key:
+            raise SchemaNotFoundError(
+                branch_name=self.name, identifier=name, message=f"Unable to find the schema {name!r} in the registry"
+            )
+
+        schema: MainSchemaTypes | None = None
+        try:
+            schema = self._cache[key]
+        except KeyError:
+            pass
 
-        raise SchemaNotFoundError(
-            branch_name=self.name, identifier=name, message=f"Unable to find the schema {name!r} in the registry"
-        )
+        if not schema:
+            raise ValueError(f"Schema {name!r} on branch {self.name} has incorrect hash: {key!r}")
+
+        if duplicate:
+            return schema.duplicate()
+        return schema
 
     def get_node(self, name: str, duplicate: bool = True) -> NodeSchema:
         """Access a specific NodeSchema, defined by its kind."""
@@ -540,13 +557,14 @@ class SchemaBranch:
         self.validate_identifiers()
         self.sync_uniqueness_constraints_and_unique_attributes()
         self.validate_uniqueness_constraints()
-        self.validate_display_label()
         self.validate_display_labels()
+        self.validate_display_label()
         self.validate_order_by()
         self.validate_default_filters()
         self.validate_parent_component()
         self.validate_human_friendly_id()
         self.validate_required_relationships()
+        self.validate_inherited_relationships_fields()
 
     def process_post_validation(self) -> None:
         self.cleanup_inherited_elements()
@@ -556,6 +574,7 @@ class SchemaBranch:
         self.process_dropdowns()
         self.process_relationships()
         self.process_human_friendly_id()
+        self.register_human_friendly_id()
 
     def _generate_identifier_string(self, node_kind: str, peer_kind: str) -> str:
         return "__".join(sorted([node_kind, peer_kind])).lower()
@@ -774,20 +793,21 @@ class SchemaBranch:
                 if len(node_schema.display_labels) == 1:
                     # If the previous display_labels consist of a single attribute convert
                     # it to an attribute based display label
-                    converted_display_label = node_schema.display_labels[0]
-                    if "__" not in converted_display_label:
-                        # Previously we allowed defining a raw attribute name as a component of a
-                        # display_label, if this is the case we need to append '__value'
-                        converted_display_label = f"{converted_display_label}__value"
-                    update_candidate.display_label = converted_display_label
+                    update_candidate.display_label = _format_display_label_component(
+                        component=node_schema.display_labels[0]
+                    )
                 else:
                     # If the previous display label consists of multiple attributes
                     # convert it to a Jinja2 based display label
                     update_candidate.display_label = " ".join(
-                        [f"{{{{ {display_label} }}}}" for display_label in node_schema.display_labels]
+                        [
+                            f"{{{{ {_format_display_label_component(component=display_label)} }}}}"
+                            for display_label in node_schema.display_labels
+                        ]
                     )
                 self.set(name=name, schema=update_candidate)
 
+            node_schema = self.get(name=name, duplicate=False)
             if not node_schema.display_label:
                 continue
 
@@ -890,7 +910,6 @@ class SchemaBranch:
         return False
 
     def validate_human_friendly_id(self) -> None:
-        self.hfids = HFIDs()
         for name in self.generic_names_without_templates + self.node_names:
             node_schema = self.get(name=name, duplicate=False)
 
@@ -924,11 +943,6 @@ class SchemaBranch:
                         rel_schemas_to_paths[rel_identifier] = (schema_path.related_schema, [])
                     rel_schemas_to_paths[rel_identifier][1].append(schema_path.attribute_path_as_str)
 
-                if node_schema.is_node_schema and node_schema.namespace not in ["Schema", "Internal"]:
-                    self.hfids.register_hfid_schema_path(
-                        kind=node_schema.kind, schema_path=schema_path, hfid=node_schema.human_friendly_id
-                    )
-
             if config.SETTINGS.main.schema_strict_mode:
                 # For every relationship referred within hfid, check whether the combination of attributes is unique is the peer schema node
                 for related_schema, attrs_paths in rel_schemas_to_paths.values():
@@ -1327,6 +1341,81 @@ class SchemaBranch:
                             f"{node.kind}: Relationship {rel.name!r} max_count must be 0 or greater than 1 when cardinality is MANY"
                         )
 
+    def validate_inherited_relationships_fields(self) -> None:
+        for name in self.node_names:
+            node_schema = self.get(name=name, duplicate=False)
+            if not node_schema.inherit_from:
+                continue
+
+            self.validate_node_inherited_relationship_fields(node_schema)
+
+    def validate_node_inherited_relationship_fields(self, node_schema: NodeSchema) -> None:
+        generics = [self.get(name=node_name, duplicate=False) for node_name in node_schema.inherit_from]
+        relationship_names = [node.relationship_names for node in generics]
+        related_relationship_names = set().union(
+            *[
+                set(relationship_name_a) & set(relationship_name_b)
+                for index, relationship_name_a in enumerate(relationship_names)
+                for relationship_name_b in relationship_names[index + 1 :]
+            ]
+        )
+        # Check that the relationship properties match
+        # for every generic node in generics list having related relationship names
+        for index, generic_a in enumerate(generics):
+            for generic_b in generics[index + 1 :]:
+                for relationship_name in related_relationship_names:
+                    try:
+                        relationship_a = generic_a.get_relationship(name=relationship_name)
+                        relationship_b = generic_b.get_relationship(name=relationship_name)
+                    except ValueError:
+                        continue
+
+                    matched, _property = self._check_relationship_properties_match(
+                        relationship_a=relationship_a, relationship_b=relationship_b
+                    )
+                    if not matched:
+                        raise ValueError(
+                            f"{node_schema.kind} inherits from '{generic_a.kind}' & '{generic_b.kind}'"
+                            f" with different '{_property}' on the '{relationship_name}' relationship"
+                        )
+
+    def _check_relationship_properties_match(
+        self, relationship_a: RelationshipSchema, relationship_b: RelationshipSchema
+    ) -> tuple[bool, str | None]:
+        compulsorily_matching_properties = (
+            "name",
+            "peer",
+            "kind",
+            "identifier",
+            "cardinality",
+            "min_count",
+            "max_count",
+            "common_parent",
+            "common_relatives",
+            "optional",
+            "branch",
+            "direction",
+            "on_delete",
+            "read_only",
+            "hierarchical",
+            "allow_override",
+        )
+        for _property in compulsorily_matching_properties:
+            if not hasattr(relationship_a, _property) or not hasattr(relationship_b, _property):
+                continue
+
+            equal_delete_actions = (None, RelationshipDeleteBehavior.NO_ACTION)
+            if (
+                _property == "on_delete"
+                and getattr(relationship_a, _property) in equal_delete_actions
+                and getattr(relationship_b, _property) in equal_delete_actions
+            ):
+                continue
+
+            if getattr(relationship_a, _property) != getattr(relationship_b, _property):
+                return False, _property
+        return True, None
+
     def process_dropdowns(self) -> None:
         for name in self.all_names:
             node = self.get(name=name, duplicate=False)
@@ -1455,6 +1544,34 @@ class SchemaBranch:
                     node.uniqueness_constraints = [hfid_uniqueness_constraint]
                 self.set(name=node.kind, schema=node)
 
+    def register_human_friendly_id(self) -> None:
+        """Register HFID automations
+
+        Register the HFIDs after all processing and validation has been done.
+        """
+
+        self.hfids = HFIDs()
+        for name in self.generic_names_without_templates + self.node_names:
+            node_schema = self.get(name=name, duplicate=False)
+
+            if not node_schema.human_friendly_id:
+                continue
+
+            allowed_types = SchemaElementPathType.ATTR_WITH_PROP | SchemaElementPathType.REL_ONE_MANDATORY_ATTR
+
+            for hfid_path in node_schema.human_friendly_id:
+                schema_path = self.validate_schema_path(
+                    node_schema=node_schema,
+                    path=hfid_path,
+                    allowed_path_types=allowed_types,
+                    element_name="human_friendly_id",
+                )
+
+                if node_schema.is_node_schema and node_schema.namespace not in ["Schema", "Internal"]:
+                    self.hfids.register_hfid_schema_path(
+                        kind=node_schema.kind, schema_path=schema_path, hfid=node_schema.human_friendly_id
+                    )
+
     def process_hierarchy(self) -> None:
         for name in self.nodes.keys():
             node = self.get_node(name=name, duplicate=False)
@@ -1750,6 +1867,8 @@ class SchemaBranch:
         """Generate order_weight for all generic schemas."""
         for name in self.generic_names:
             node = self.get(name=name, duplicate=False)
+            if node.namespace == "Template":
+                continue
 
             items_to_update = [item for item in node.attributes + node.relationships if not item.order_weight]
 
@@ -1813,10 +1932,36 @@ class SchemaBranch:
 
             self.set(name=name, schema=template)
 
+    def _generate_generics_templates_weight(self) -> None:
+        """Generate order_weight for generic templates.
+
+        The order of the fields for the template must respect the order of the node.
+        """
+        for name in self.generic_names:
+            generic_node = self.get(name=name, duplicate=False)
+            try:
+                template = self.get(name=self._get_object_template_kind(node_kind=generic_node.kind), duplicate=True)
+            except SchemaNotFoundError:
+                continue
+
+            generic_node_weights = {
+                item.name: item.order_weight
+                for item in generic_node.attributes + generic_node.relationships
+                if item.order_weight is not None
+            }
+
+            for item in template.attributes + template.relationships:
+                if item.order_weight:
+                    continue
+                item.order_weight = generic_node_weights[item.name] if item.name in generic_node_weights else None
+
+            self.set(name=template.kind, schema=template)
+
     def generate_weight(self) -> None:
         self._generate_weight_generics()
         self._generate_weight_nodes_profiles()
         self._generate_weight_templates()
+        self._generate_generics_templates_weight()
 
     def cleanup_inherited_elements(self) -> None:
         for name in self.node_names:
@@ -2142,7 +2287,7 @@ class SchemaBranch:
         )
 
         for node_attr in node.attributes:
-            if node_attr.read_only or node_attr.optional is False:
+            if not node_attr.support_profiles:
                 continue
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
@@ -2447,3 +2592,16 @@ class SchemaBranch:
                 updated_used_by_node = set(chain(template_schema_kinds, set(core_node_schema.used_by)))
                 core_node_schema.used_by = sorted(updated_used_by_node)
                 self.set(name=InfrahubKind.NODE, schema=core_node_schema)
+
+
+def _format_display_label_component(component: str) -> str:
+    """Return correct format for display_label.
+
+    Previously both the format of 'name' and 'name__value' was
+    supported this function ensures that the proper 'name__value'
+    format is used
+    """
+    if "__" in component:
+        return component
+
+    return f"{component}__value"

infrahub/database/graph.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from infrahub.core.graph import GRAPH_VERSION
+from infrahub.core.initialization import get_root_node
+from infrahub.log import get_logger
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+
+log = get_logger()
+
+
+async def validate_graph_version(db: InfrahubDatabase) -> None:
+    root = await get_root_node(db=db)
+    if root.graph_version != GRAPH_VERSION:
+        log.warning(
+            f"Expected database graph version {GRAPH_VERSION} but got {root.graph_version}, possibly 'infrahub upgrade' has not been executed"
+        )

infrahub/display_labels/tasks.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import cast
 
+from infrahub_sdk.exceptions import URLNotFoundError
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.logging import get_run_logger
@@ -53,12 +54,17 @@ async def display_label_jinja2_update_value(
         log.debug(f"Ignoring to update {obj} with existing value on display_label={value}")
         return
 
-    await client.execute_graphql(
-        query=UPDATE_DISPLAY_LABEL,
-        variables={"id": obj.node_id, "kind": node_kind, "value": value},
-        branch_name=branch_name,
-    )
-    log.info(f"Updating {node_kind}.display_label='{value}' ({obj.node_id})")
+    try:
+        await client.execute_graphql(
+            query=UPDATE_DISPLAY_LABEL,
+            variables={"id": obj.node_id, "kind": node_kind, "value": value},
+            branch_name=branch_name,
+        )
+        log.info(f"Updating {node_kind}.display_label='{value}' ({obj.node_id})")
+    except URLNotFoundError:
+        log.warning(
+            f"Updating {node_kind}.display_label='{value}' ({obj.node_id}) failed for branch {branch_name} (branch not found)"
+        )
 
 
 @flow(
@@ -152,7 +158,7 @@ async def display_labels_setup_jinja2(
 
 @flow(
     name="trigger-update-display-labels",
-    flow_run_name="Trigger updates for display labels for kind",
+    flow_run_name="Trigger updates for display labels for {kind}",
 )
 async def trigger_update_display_labels(
     branch_name: str,

infrahub/events/branch_action.py

@@ -109,7 +109,7 @@ class BranchRebasedEvent(InfrahubEvent):
 
     event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.rebased"
 
-    branch_id: str = Field(..., description="The ID of the mutated node")
+    branch_id: str = Field(..., description="The ID of the branch")
     branch_name: str = Field(..., description="The name of the branch")
 
     def get_resource(self) -> dict[str, str]:
@@ -128,3 +128,29 @@ class BranchRebasedEvent(InfrahubEvent):
             RefreshRegistryRebasedBranch(branch=self.branch_name),
         ]
         return events
+
+
+class BranchMigratedEvent(InfrahubEvent):
+    """Event generated when a branch has been migrated"""
+
+    event_name: ClassVar[str] = f"{EVENT_NAMESPACE}.branch.migrated"
+
+    branch_id: str = Field(..., description="The ID of the branch")
+    branch_name: str = Field(..., description="The name of the branch")
+
+    def get_resource(self) -> dict[str, str]:
+        return {
+            "prefect.resource.id": f"infrahub.branch.{self.branch_name}",
+            "infrahub.branch.id": self.branch_id,
+            "infrahub.branch.name": self.branch_name,
+        }
+
+    def get_messages(self) -> list[InfrahubMessage]:
+        events: list[InfrahubMessage] = [
+            # EventBranchMigrated(
+            #     branch=self.branch,
+            #     meta=self.get_message_meta(),
+            # ),
+            RefreshRegistryRebasedBranch(branch=self.branch_name),
+        ]
+        return events

infrahub/generators/tasks.py

@@ -23,6 +23,7 @@ from infrahub.generators.models import (
 )
 from infrahub.git.base import extract_repo_file_information
 from infrahub.git.repository import get_initialized_repo
+from infrahub.git.utils import fetch_proposed_change_generator_definition_targets
 from infrahub.workers.dependencies import get_client, get_workflow
 from infrahub.workflows.catalogue import REQUEST_GENERATOR_DEFINITION_RUN, REQUEST_GENERATOR_RUN
 from infrahub.workflows.utils import add_tags
@@ -195,14 +196,9 @@ async def request_generator_definition_run(
         branch=model.branch,
     )
 
-    group = await client.get(
-        kind=InfrahubKind.GENERICGROUP,
-        prefetch_relationships=True,
-        populate_store=True,
-        id=model.generator_definition.group_id,
-        branch=model.branch,
+    group = await fetch_proposed_change_generator_definition_targets(
+        client=client, branch=model.branch, definition=model.generator_definition
     )
-    await group.members.fetch()
 
     instance_by_member = {}
     for instance in existing_instances:

infrahub/git/base.py

@@ -941,7 +941,10 @@ class InfrahubRepositoryBase(BaseModel, ABC):
     def _raise_enriched_error_static(
         error: GitCommandError, name: str, location: str, branch_name: str | None = None
     ) -> NoReturn:
-        if "Repository not found" in error.stderr or "does not appear to be a git" in error.stderr:
+        if any(
+            err in error.stderr
+            for err in ("Repository not found", "does not appear to be a git", "Failed to connect to")
+        ):
             raise RepositoryConnectionError(identifier=name) from error
 
         if "error: pathspec" in error.stderr:

infrahub/git/integrator.py

@@ -1371,7 +1371,7 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
         message: CheckArtifactCreate | RequestArtifactGenerate,
     ) -> ArtifactGenerateResult:
         response = await self.sdk.query_gql_query(
-            name=message.query,
+            name=message.query_id,
             variables=message.variables,
             update_group=True,
             subscribers=[artifact.id],

infrahub/git/models.py

@@ -38,7 +38,8 @@ class RequestArtifactGenerate(BaseModel):
     target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")
     artifact_id: str | None = Field(default=None, description="The id of the artifact if it previously existed")
-    query: str = Field(..., description="The name of the query to use when collecting data")
+    query: str = Field(..., description="The name of the query to use when collecting data")  # Deprecated
+    query_id: str = Field(..., description="The id of the query to use when collecting data")
     timeout: int = Field(..., description="Timeout for requests used to generate this artifact")
     variables: dict = Field(..., description="Input variables when generating the artifact")
     context: InfrahubContext = Field(..., description="The context of the task")