infrahub-server 1.4.9__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

infrahub/core/relationship/model.py

@@ -381,14 +381,33 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
 
         node = await self.get_node(db=db)
 
+        flag_properties_to_update = {}
+        for prop_name in self._flag_properties:
+            if prop_name not in properties_to_update:
+                continue
+            value = getattr(self, prop_name)
+            if value is not None:
+                flag_properties_to_update[prop_name] = value
+
+        node_properties_to_update = {}
+        for prop_name in self._node_properties:
+            if prop_name not in properties_to_update:
+                continue
+            if value := getattr(self, f"{prop_name}_id"):
+                node_properties_to_update[prop_name] = value
+
+        if not flag_properties_to_update and not node_properties_to_update:
+            return
+
         query = await RelationshipUpdatePropertyQuery.init(
             db=db,
+            branch=branch,
             source=node,
             rel=self,
-            properties_to_update=properties_to_update,
-            data=data,
-            branch=branch,
             at=update_at,
+            flag_properties_to_update=flag_properties_to_update,
+            node_properties_to_update=node_properties_to_update,
+            rel_node_id=data.rel_node_id,
         )
         await query.execute(db=db)
 
@@ -570,7 +589,9 @@ class RelationshipValidatorList:
         ValidationError: If the number of relationships is not within the min and max count.
     """
 
-    def __init__(self, *relationships: Relationship, name: str, min_count: int = 0, max_count: int = 0) -> None:
+    def __init__(
+        self, *relationships: Relationship, name: str, min_count: int | None = 0, max_count: int | None = 0
+    ) -> None:
         """Initialize list for Relationship but with validation against min/max count.
 
         Args:
@@ -580,8 +601,14 @@ class RelationshipValidatorList:
         Raises:
             ValidationError: The number of relationships is not within the min and max count.
         """
-        if max_count < min_count:
+        if max_count is not None and min_count is not None and max_count < min_count:
             raise ValidationError({"msg": "max_count must be greater than min_count"})
+
+        if max_count is None:
+            max_count = 0
+        if min_count is None:
+            min_count = 0
+
         self.min_count: int = min_count
         self.max_count: int = max_count
         self.name = name
@@ -726,15 +753,22 @@ class RelationshipManager:
         # TODO Ideally this information should come from the Schema
         self.rel_class = Relationship
 
-        self._relationships: RelationshipValidatorList = RelationshipValidatorList(
-            name=self.schema.name,
-            min_count=0 if self.schema.optional else self.schema.min_count,
-            max_count=self.schema.max_count,
-        )
+        self._relationships: RelationshipValidatorList = self._get_init_relationships()
         self._relationship_id_details: RelationshipUpdateDetails | None = None
         self.has_fetched_relationships: bool = False
         self.lock = asyncio.Lock()
 
+    def _get_init_relationships(self) -> RelationshipValidatorList:
+        min_count = self.schema.min_count
+        max_count: int | None = self.schema.max_count if self.schema.max_count > 0 else None
+        if self.schema.optional:
+            min_count = 0
+        return RelationshipValidatorList(
+            name=self.schema.name,
+            min_count=min_count,
+            max_count=max_count,
+        )
+
     @classmethod
     async def init(
         cls,
@@ -909,6 +943,19 @@ class RelationshipManager:
             return registry.get_global_branch()
         return self.branch
 
+    async def get_db_peers(
+        self, db: InfrahubDatabase, at: Timestamp | None = None, branch_agnostic: bool = False
+    ) -> list[RelationshipPeerData]:
+        query = await RelationshipGetPeerQuery.init(
+            db=db,
+            source=self.node,
+            at=at or self.at,
+            rel=self.rel_class(schema=self.schema, branch=self.branch, node=self.node),
+            branch_agnostic=branch_agnostic,
+        )
+        await query.execute(db=db)
+        return list(query.get_peers())
+
     async def fetch_relationship_ids(
         self,
         db: InfrahubDatabase,
@@ -926,16 +973,9 @@ class RelationshipManager:
 
         current_peer_ids = [rel.get_peer_id() for rel in self._relationships]
 
-        query = await RelationshipGetPeerQuery.init(
-            db=db,
-            source=self.node,
-            at=at or self.at,
-            rel=self.rel_class(schema=self.schema, branch=self.branch, node=self.node),
-            branch_agnostic=branch_agnostic,
-        )
-        await query.execute(db=db)
+        peers = await self.get_db_peers(db=db, at=at, branch_agnostic=branch_agnostic)
 
-        peers_database: dict = {str(peer.peer_id): peer for peer in query.get_peers()}
+        peers_database: dict = {str(peer.peer_id): peer for peer in peers}
         peer_ids = list(peers_database.keys())
 
         # Calculate which peer should be added or removed

infrahub/core/schema/attribute_schema.py

@@ -202,7 +202,6 @@ class AttributeSchema(GeneratedAttributeSchema):
         param_prefix: str | None = None,
         db: InfrahubDatabase | None = None,
         partial_match: bool = False,
-        support_profiles: bool = False,
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
         if self.enum:
             filter_value = self.convert_enum_to_value(filter_value)
@@ -217,7 +216,6 @@ class AttributeSchema(GeneratedAttributeSchema):
             param_prefix=param_prefix,
             db=db,
             partial_match=partial_match,
-            support_profiles=support_profiles,
         )
 
 

infrahub/core/schema/definitions/core/repository.py

@@ -282,5 +282,12 @@ core_generic_repository = GenericSchema(
             cardinality=Cardinality.MANY,
             order_weight=12000,
         ),
+        Rel(
+            name="groups_objects",
+            peer=InfrahubKind.REPOSITORYGROUP,
+            optional=True,
+            cardinality=Cardinality.MANY,
+            order_weight=13000,
+        ),
     ],
 )

infrahub/core/schema/relationship_schema.py

@@ -91,7 +91,6 @@ class RelationshipSchema(GeneratedRelationshipSchema):
         include_match: bool = True,
         param_prefix: str | None = None,
         partial_match: bool = False,
-        support_profiles: bool = False,  # noqa: ARG002
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
         """Generate Query String Snippet to filter the right node."""
 

infrahub/core/schema/schema_branch.py

@@ -18,6 +18,7 @@ from infrahub.computed_attribute.constants import VALID_KINDS as VALID_COMPUTED_
 from infrahub.core.constants import (
     OBJECT_TEMPLATE_NAME_ATTR,
     OBJECT_TEMPLATE_RELATIONSHIP_NAME,
+    PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
     RESERVED_ATTR_GEN_NAMES,
     RESERVED_ATTR_REL_NAMES,
     RESTRICTED_NAMESPACES,
@@ -1934,7 +1935,7 @@ class SchemaBranch:
 
             profiles_rel_settings: dict[str, Any] = {
                 "name": "profiles",
-                "identifier": "node__profile",
+                "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
                 "peer": InfrahubKind.PROFILE,
                 "kind": RelationshipKind.PROFILE,
                 "cardinality": RelationshipCardinality.MANY,
@@ -1997,7 +1998,7 @@ class SchemaBranch:
             relationships=[
                 RelationshipSchema(
                     name="related_nodes",
-                    identifier="node__profile",
+                    identifier=PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
                     peer=node.kind,
                     kind=RelationshipKind.PROFILE,
                     cardinality=RelationshipCardinality.MANY,

infrahub/generators/models.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field
 class RequestGeneratorRun(BaseModel):
     """Runs a generator."""
 
-    generator_definition: ProposedChangeGeneratorDefinition = Field(..., description="The Generator definition")
+    generator_definition: GeneratorDefinitionModel = Field(..., description="The Generator definition")
     generator_instance: str | None = Field(
         default=None, description="The id of the generator instance if it previously existed"
     )
@@ -31,14 +31,33 @@ class RequestGeneratorDefinitionRun(BaseModel):
     target_members: list[str] = Field(default_factory=list, description="List of targets to run the generator for")
 
 
-class ProposedChangeGeneratorDefinition(BaseModel):
-    definition_id: str
-    definition_name: str
-    query_name: str
-    convert_query_response: bool
-    query_models: list[str]
-    repository_id: str
-    class_name: str
-    file_path: str
-    parameters: dict
-    group_id: str
+class GeneratorDefinitionModel(BaseModel):
+    definition_id: str = Field(..., description="The id of the generator definition.")
+    definition_name: str = Field(..., description="The name of the generator definition.")
+    query_name: str = Field(..., description="The name of the query to use when collecting data.")
+    convert_query_response: bool = Field(
+        ...,
+        description="Decide if the generator should convert the result of the GraphQL query to SDK InfrahubNode objects.",
+    )
+    class_name: str = Field(..., description="The name of the generator class to run.")
+    file_path: str = Field(..., description="The file path of the generator in the repository.")
+    group_id: str = Field(..., description="The group to target when running this generator")
+    parameters: dict = Field(..., description="The input parameters required to run this check")
+
+    @classmethod
+    def from_pc_generator_definition(cls, model: ProposedChangeGeneratorDefinition) -> GeneratorDefinitionModel:
+        return GeneratorDefinitionModel(
+            definition_id=model.definition_id,
+            definition_name=model.definition_name,
+            query_name=model.query_name,
+            convert_query_response=model.convert_query_response,
+            class_name=model.class_name,
+            file_path=model.file_path,
+            group_id=model.group_id,
+            parameters=model.parameters,
+        )
+
+
+class ProposedChangeGeneratorDefinition(GeneratorDefinitionModel):
+    query_models: list[str] = Field(..., description="The models to use when collecting data.")
+    repository_id: str = Field(..., description="The id of the repository.")

infrahub/generators/tasks.py

@@ -15,6 +15,7 @@ from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001 needed for prefect flow
 from infrahub.core.constants import GeneratorInstanceStatus, InfrahubKind
 from infrahub.generators.models import (
+    GeneratorDefinitionModel,
     ProposedChangeGeneratorDefinition,
     RequestGeneratorDefinitionRun,
     RequestGeneratorRun,
@@ -52,6 +53,7 @@ async def run_generator(model: RequestGeneratorRun) -> None:
         name=model.generator_definition.definition_name,
         class_name=model.generator_definition.class_name,
         file_path=model.generator_definition.file_path,
+        parameters=model.generator_definition.parameters,
         query=model.generator_definition.query_name,
         targets=model.generator_definition.group_id,
         convert_query_response=model.generator_definition.convert_query_response,
@@ -213,7 +215,7 @@ async def request_generator_definition_run(
 
         generator_instance = instance_by_member.get(member.id)
         request_generator_run_model = RequestGeneratorRun(
-            generator_definition=model.generator_definition,
+            generator_definition=GeneratorDefinitionModel.from_pc_generator_definition(model.generator_definition),
             commit=repository.commit.value,
             generator_instance=generator_instance,
             repository_id=repository.id,

infrahub/git/base.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, NoReturn
 from uuid import UUID  # noqa: TC003
 
 import git
-from git import Blob, Repo
+from git import BadName, Blob, Repo
 from git.exc import GitCommandError, InvalidGitRepositoryError
 from git.refs.remote import RemoteReference
 from infrahub_sdk import InfrahubClient  # noqa: TC002
@@ -67,6 +67,15 @@ class RepoFileInformation(BaseModel):
     """Extension of the file Example: py """
 
 
+class RepoChangedFiles(BaseModel):
+    added: list[str] = Field(default_factory=list)
+    copied: list[tuple[str, str]] = Field(default_factory=list)
+    deleted: list[str] = Field(default_factory=list)
+    renamed: list[tuple[str, str]] = Field(default_factory=list)
+    modified: list[str] = Field(default_factory=list)
+    type_changed: list[tuple[str, str]] = Field(default_factory=list)
+
+
 def extract_repo_file_information(
     full_filename: Path, repo_directory: Path, worktree_directory: Path | None = None
 ) -> RepoFileInformation:
@@ -970,3 +979,31 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         if branch_name == self.default_branch and branch_name != registry.default_branch:
             return registry.default_branch
         return branch_name
+
+    def get_changed_files(self, first_commit: str, second_commit: str | None = None) -> RepoChangedFiles:
+        """Return the changes between two commits in this repo."""
+        changes = RepoChangedFiles()
+        repo = self.get_git_repo_main()
+
+        try:
+            commit_a = repo.commit(first_commit)
+            commit_b = repo.commit(second_commit) if second_commit else repo.head.commit
+        except BadName as exc:
+            raise CommitNotFoundError(identifier=str(self.id), commit=exc.args[0]) from exc
+
+        for diff in commit_a.diff(commit_b):
+            match diff.change_type:
+                case "A":
+                    changes.added.append(diff.b_path)
+                case "C":
+                    changes.copied.append((diff.a_path, diff.b_path))
+                case "D":
+                    changes.deleted.append(diff.a_path)
+                case "R":
+                    changes.renamed.append((diff.a_path, diff.b_path))
+                case "M":
+                    changes.modified.append(diff.b_path)
+                case "T":
+                    changes.type_changed.append((diff.a_path, diff.b_path))
+
+        return changes

infrahub/graphql/api/dependencies.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from infrahub import config
 
 from ..app import InfrahubGraphQLApp
@@ -36,5 +34,5 @@ def build_graphql_query_permission_checker() -> GraphQLQueryPermissionChecker:
     )
 
 
-def build_graphql_app(**kwargs: Any) -> InfrahubGraphQLApp:
-    return InfrahubGraphQLApp(build_graphql_query_permission_checker(), **kwargs)
+def build_graphql_app() -> InfrahubGraphQLApp:
+    return InfrahubGraphQLApp(build_graphql_query_permission_checker())

infrahub/graphql/api/endpoints.py

@@ -9,7 +9,7 @@ from starlette.routing import Route, WebSocketRoute
 
 from infrahub.api.dependencies import get_branch_dep, get_current_user
 from infrahub.core import registry
-from infrahub.graphql.manager import GraphQLSchemaManager
+from infrahub.graphql.registry import registry as graphql_registry
 
 from .dependencies import build_graphql_app
 
@@ -32,6 +32,6 @@ async def get_graphql_schema(
     branch: Branch = Depends(get_branch_dep), _: AccountSession = Depends(get_current_user)
 ) -> PlainTextResponse:
     schema_branch = registry.schema.get_schema_branch(name=branch.name)
-    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
+    gqlm = graphql_registry.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
     graphql_schema = gqlm.get_graphql_schema()
     return PlainTextResponse(content=print_schema(graphql_schema))

infrahub/graphql/app.py

@@ -23,7 +23,6 @@ from graphql import (
     ExecutionResult,
     GraphQLError,
     GraphQLFormattedError,
-    Middleware,
     OperationType,
     graphql,
     parse,
@@ -59,6 +58,7 @@ from .metrics import (
     GRAPHQL_RESPONSE_SIZE_METRICS,
     GRAPHQL_TOP_LEVEL_QUERIES_METRICS,
 )
+from .middleware import raise_on_mutation_on_branch_needing_rebase
 
 if TYPE_CHECKING:
     import graphene
@@ -99,7 +99,6 @@ class InfrahubGraphQLApp:
         *,
         on_get: Callable[[Request], Response | Awaitable[Response]] | None = None,
         root_value: RootValue = None,
-        middleware: Middleware | None = None,
         error_formatter: Callable[[GraphQLError], GraphQLFormattedError] = format_error,
         execution_context_class: type[ExecutionContext] | None = None,
     ) -> None:
@@ -107,7 +106,6 @@ class InfrahubGraphQLApp:
         self.on_get = on_get
         self.root_value = root_value
         self.error_formatter = error_formatter
-        self.middleware = middleware
         self.execution_context_class = execution_context_class
         self.logger = get_logger(name="infrahub.graphql")
         self.permission_checker = permission_checker
@@ -259,7 +257,7 @@ class InfrahubGraphQLApp:
                     source=query,
                     context_value=graphql_params.context,
                     root_value=self.root_value,
-                    middleware=self.middleware,
+                    middleware=[raise_on_mutation_on_branch_needing_rebase],
                     variable_values=variable_values,
                     operation_name=operation_name,
                     execution_context_class=self.execution_context_class,

infrahub/graphql/initialization.py

@@ -9,12 +9,11 @@ from infrahub.context import InfrahubContext
 from infrahub.core import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError
+from infrahub.graphql.registry import registry as graphql_registry
 from infrahub.graphql.resolvers.many_relationship import ManyRelationshipResolver
 from infrahub.graphql.resolvers.single_relationship import SingleRelationshipResolver
 from infrahub.permissions import PermissionManager
 
-from .manager import GraphQLSchemaManager
-
 if TYPE_CHECKING:
     from graphql import GraphQLSchema
     from starlette.requests import HTTPConnection
@@ -91,7 +90,7 @@ async def prepare_graphql_params(
 ) -> GraphqlParams:
     branch = registry.get_branch_from_registry(branch=branch)
     schema_branch = registry.schema.get_schema_branch(name=branch.name)
-    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
+    gqlm = graphql_registry.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
     gql_schema = gqlm.get_graphql_schema(
         include_query=include_query,
         include_mutation=include_mutation,