infrahub-server 1.7.0rc0__py3-none-any.whl → 1.7.2__py3-none-any.whl

infrahub/actions/gather.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from graphql import graphql
 from infrahub_sdk.graphql import Query
 from prefect import task
 from prefect.cache_policies import NONE
@@ -8,6 +7,7 @@ from prefect.cache_policies import NONE
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.registry import registry
 from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
+from infrahub.graphql.execution import execute_graphql_query
 from infrahub.graphql.initialization import prepare_graphql_params
 
 from .models import ActionTriggerRuleTriggerDefinition
@@ -95,7 +95,7 @@ async def gather_trigger_action_rules(db: InfrahubDatabase) -> list[ActionTrigge
         db=db,
         branch=registry.default_branch,
     )
-    response = await graphql(
+    response = await execute_graphql_query(
         schema=gql_params.schema,
         source=trigger_query.render(),
         context_value=gql_params.context,

infrahub/api/query.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from fastapi import APIRouter, Body, Depends, Path, Query, Request
-from graphql import graphql
 from pydantic import BaseModel, Field
 
 from infrahub.api.dependencies import BranchParams, get_branch_params, get_current_user, get_db
@@ -14,6 +13,7 @@ from infrahub.core.protocols import CoreGraphQLQuery
 from infrahub.database import InfrahubDatabase  # noqa: TC001
 from infrahub.graphql.analyzer import InfrahubGraphQLQueryAnalyzer
 from infrahub.graphql.api.dependencies import build_graphql_query_permission_checker
+from infrahub.graphql.execution import cached_parse, execute_graphql_query
 from infrahub.graphql.initialization import prepare_graphql_params
 from infrahub.graphql.metrics import (
     GRAPHQL_DURATION_METRICS,
@@ -75,6 +75,7 @@ async def execute_query(
         schema=gql_params.schema,
         schema_branch=schema_branch,
         branch=branch_params.branch,
+        document=cached_parse(gql_query.query.value),
     )
     await permission_checker.check(
         db=db,
@@ -93,7 +94,7 @@ async def execute_query(
     }
 
     with GRAPHQL_DURATION_METRICS.labels(**labels).time():
-        result = await graphql(
+        result = await execute_graphql_query(
             schema=gql_params.schema,
             source=gql_query.query.value,
             context_value=gql_params.context,

infrahub/api/schema.py

@@ -36,6 +36,7 @@ from infrahub.core.schema import (
     TemplateSchema,
 )
 from infrahub.core.schema.constants import SchemaNamespace  # noqa: TC001
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.validators.models.validate_migration import (
     SchemaValidateMigrationData,
     SchemaValidatorPathResponseData,
@@ -353,6 +354,8 @@ async def load_schema(
         if error_messages:
             raise SchemaNotValidError(",\n".join(error_messages))
 
+        schema_load_at = Timestamp()
+
         # ----------------------------------------------------------
         # Update the schema
         # ----------------------------------------------------------
@@ -367,6 +370,7 @@ async def load_schema(
                 limit=result.diff.all,
                 update_db=True,
                 user_id=account_session.account_id,
+                at=schema_load_at,
             )
             branch.update_schema_hash()
             log.info("Schema has been updated", branch=branch.name, hash=branch.active_schema_hash.main)
@@ -389,6 +393,7 @@ async def load_schema(
             previous_schema=origin_schema,
             migrations=result.migrations,
             user_id=account_session.account_id,
+            at=schema_load_at,
         )
         migration_error_msgs = await service.workflow.execute_workflow(
             workflow=SCHEMA_APPLY_MIGRATION,

infrahub/api/transformation.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from fastapi import APIRouter, Depends, Path, Request
-from graphql import graphql
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from infrahub.api.dependencies import (
@@ -22,6 +21,7 @@ from infrahub.core.protocols import (
 )
 from infrahub.database import InfrahubDatabase  # noqa: TC001
 from infrahub.exceptions import TransformError
+from infrahub.graphql.execution import execute_graphql_query
 from infrahub.graphql.initialization import prepare_graphql_params
 from infrahub.graphql.utils import extract_data
 from infrahub.transformations.models import TransformJinjaTemplateData, TransformPythonData
@@ -69,7 +69,7 @@ async def transform_python(
             db=dbs, branch=branch_params.branch, at=branch_params.at, service=request.app.state.service
         )
 
-        result = await graphql(
+        result = await execute_graphql_query(
             schema=gql_params.schema,
             source=query.query.value,
             context_value=gql_params.context,
@@ -134,7 +134,7 @@ async def transform_jinja2(
             db=dbs, branch=branch_params.branch, at=branch_params.at, service=request.app.state.service
         )
 
-        result = await graphql(
+        result = await execute_graphql_query(
             schema=gql_params.schema,
             source=query.query.value,
             context_value=gql_params.context,

infrahub/cli/db.py

@@ -40,10 +40,11 @@ from infrahub.core.migrations.exceptions import MigrationFailureError
 from infrahub.core.migrations.graph import get_graph_migrations, get_migration_by_number
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
-from infrahub.core.migrations.shared import get_migration_console
+from infrahub.core.migrations.shared import MigrationInput, get_migration_console
 from infrahub.core.schema import SchemaRoot, core_models, internal_schema
 from infrahub.core.schema.definitions.deprecated import deprecated_models
 from infrahub.core.schema.manager import SchemaManager
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.validators.models.validate_migration import SchemaValidateMigrationData
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.database import DatabaseType
@@ -357,7 +358,7 @@ async def migrate_database(
     root_node = await get_root_node(db=db)
 
     for migration in migrations:
-        execution_result = await migration.execute(db=db)
+        execution_result = await migration.execute(migration_input=MigrationInput(db=db))
         validation_result = None
 
         if execution_result.success:
@@ -502,6 +503,7 @@ async def update_core_schema(db: InfrahubDatabase, initialize: bool = True, debu
     schema_default_branch.process()
     registry.schema.set_schema_branch(name=default_branch.name, schema=schema_default_branch)
 
+    update_at = Timestamp()
     async with db.start_transaction() as dbt:
         await registry.schema.update_schema_branch(
             schema=candidate_schema,
@@ -510,6 +512,7 @@ async def update_core_schema(db: InfrahubDatabase, initialize: bool = True, debu
             diff=result.diff,
             limit=result.diff.all,
             update_db=True,
+            at=update_at,
         )
         default_branch.update_schema_hash()
         get_migration_console().log(
@@ -527,6 +530,7 @@ async def update_core_schema(db: InfrahubDatabase, initialize: bool = True, debu
         new_schema=candidate_schema,
         previous_schema=origin_schema,
         migrations=result.migrations,
+        at=update_at,
     )
     migration_error_msgs = await schema_apply_migrations(message=apply_migration_data)
 

infrahub/computed_attribute/gather.py

@@ -14,6 +14,7 @@ from infrahub.core.registry import registry
 from infrahub.database import InfrahubDatabase  # noqa: TC001  needed for prefect flow
 from infrahub.git.utils import get_repositories_commit_per_branch
 from infrahub.graphql.analyzer import InfrahubGraphQLQueryAnalyzer
+from infrahub.graphql.execution import cached_parse
 from infrahub.graphql.initialization import prepare_graphql_params
 
 from .models import (
@@ -74,6 +75,7 @@ async def gather_python_transform_attributes(
             branch=branch,
             schema_branch=schema_branch,
             schema=graphql_params.schema,
+            document=cached_parse(query.query.value),
         )
         for attribute in transform_attributes[transform.name.value]:
             python_transform_computed_attribute = PythonTransformComputedAttribute(

infrahub/config.py

@@ -532,8 +532,8 @@ class HTTPSettings(BaseSettings):
 
         return self
 
-    def get_tls_context(self) -> ssl.SSLContext:
-        if self.tls_insecure:
+    def get_tls_context(self, force_verify: bool = False) -> ssl.SSLContext:
+        if self.tls_insecure and not force_verify:
             return ssl._create_unverified_context()
 
         if not self.tls_ca_bundle:

infrahub/core/attribute.py

@@ -366,6 +366,24 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
 
         return await self._update(db=db, user_id=user_id, at=save_at)
 
+    def get_branch_for_delete(self) -> Branch:
+        """Get the appropriate branch for explicit attribute delete operations.
+
+        For branch-agnostic attributes on branch-aware nodes, use the current branch
+        to create branch-scoped deletion edges rather than global deletion.
+
+        Returns:
+            Branch: The branch to use for the delete operation
+        """
+        if (
+            self.schema.branch == BranchSupportType.AGNOSTIC
+            and self.node is not None
+            and self.node._schema.branch == BranchSupportType.AWARE
+        ):
+            return self.branch
+
+        return self.get_branch_based_on_support_type()
+
     async def delete(
         self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID, at: Timestamp | None = None
     ) -> AttributeChangelog | None:
@@ -373,7 +391,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
             return None
 
         delete_at = Timestamp(at)
-        branch = self.get_branch_based_on_support_type()
+        branch = self.get_branch_for_delete()
 
         query = await AttributeDeleteQuery.init(db=db, branch=branch, attr=self, user_id=user_id, at=delete_at)
         await query.execute(db=db)
@@ -642,9 +660,10 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin, MetadataInterface):
         hierarchy_level = branch.hierarchy_level
         if self.schema.branch == BranchSupportType.AGNOSTIC:
             branch = registry.get_global_branch()
+            hierarchy_level = 1
         elif self.schema.branch == BranchSupportType.LOCAL and self.node._schema.branch == BranchSupportType.AGNOSTIC:
             branch = registry.get_global_branch()
-            hierarchy_level = 0
+            hierarchy_level = 1
         data = AttributeCreateData(
             uuid=str(UUIDT()),
             name=self.name,

infrahub/core/branch/models.py

@@ -333,7 +333,7 @@ class Branch(StandardNode):
                     f"({rel}.branch IN $branch{idx} AND {rel}.from <= $time{idx} AND {rel}.to IS NULL)"
                 )
                 filters_per_rel.append(
-                    f"({rel}.branch IN $branch{idx} AND {rel}.from <= $time{idx} AND {rel}.to >= $time{idx})"
+                    f"({rel}.branch IN $branch{idx} AND {rel}.from <= $time{idx} AND {rel}.to > $time{idx})"
                 )
 
             if not include_outside_parentheses:
@@ -366,7 +366,9 @@ class Branch(StandardNode):
         at = Timestamp(at)
         at_str = at.to_string()
         if branch_agnostic:
-            filter_str = f"{variable_name}.from < ${pp}time1 AND ({variable_name}.to IS NULL or {variable_name}.to >= ${pp}time1)"
+            filter_str = (
+                f"{variable_name}.from < ${pp}time1 AND ({variable_name}.to IS NULL or {variable_name}.to > ${pp}time1)"
+            )
             params[f"{pp}time1"] = at_str
             return filter_str, params
 
@@ -380,132 +382,24 @@ class Branch(StandardNode):
         for idx in range(len(branches_times)):
             filters.append(
                 f"({variable_name}.branch IN ${pp}branch{idx} "
-                f"AND {variable_name}.from < ${pp}time{idx} AND {variable_name}.to IS NULL)"
+                f"AND {variable_name}.from <= ${pp}time{idx} AND {variable_name}.to IS NULL)"
             )
             filters.append(
                 f"({variable_name}.branch IN ${pp}branch{idx} "
-                f"AND {variable_name}.from < ${pp}time{idx} "
-                f"AND {variable_name}.to >= ${pp}time{idx})"
+                f"AND {variable_name}.from <= ${pp}time{idx} "
+                f"AND {variable_name}.to > ${pp}time{idx})"
             )
 
         filter_str = "(" + "\n OR ".join(filters) + ")"
 
         return filter_str, params
 
-    def get_query_filter_relationships_range(
-        self,
-        rel_labels: list,
-        start_time: Timestamp,
-        end_time: Timestamp,
-        include_outside_parentheses: bool = False,
-        include_global: bool = False,
-    ) -> tuple[list, dict]:
-        """Generate a CYPHER Query filter based on a list of relationships to query a range of values in the graph.
-        The goal is to return all the values that are valid during this timerange.
-        """
-
-        filters = []
-        params = {}
-
-        if not isinstance(rel_labels, list):
-            raise TypeError(f"rel_labels must be a list, not a {type(rel_labels)}")
-
-        start_time = Timestamp(start_time)
-        end_time = Timestamp(end_time)
-
-        if include_global:
-            branches_times = self.get_branches_and_times_to_query_global(at=start_time)
-        else:
-            branches_times = self.get_branches_and_times_to_query(at=start_time)
-
-        params["branches"] = list({branch for branches in branches_times for branch in branches})
-        params["start_time"] = start_time.to_string()
-        params["end_time"] = end_time.to_string()
-
-        for rel in rel_labels:
-            filters_per_rel = [
-                f"({rel}.branch IN $branches AND {rel}.from <= $end_time AND {rel}.to IS NULL)",
-                f"({rel}.branch IN $branches AND ({rel}.from <= $end_time OR ({rel}.to >= $start_time AND {rel}.to <= $end_time)))",
-            ]
-
-            if not include_outside_parentheses:
-                filters.append("\n OR ".join(filters_per_rel))
-
-            filters.append("(" + "\n OR ".join(filters_per_rel) + ")")
-
-        return filters, params
-
-    def get_query_filter_relationships_diff(
-        self, rel_labels: list, diff_from: Timestamp, diff_to: Timestamp
-    ) -> tuple[list, dict]:
-        """
-        Generate a CYPHER Query filter to query all events that are applicable to a given branch based
-        - The time when the branch as created
-        - The branched_from time of the branch
-        - The diff_to and diff_from time as provided
-        """
-
-        if not isinstance(rel_labels, list):
-            raise TypeError(f"rel_labels must be a list, not a {type(rel_labels)}")
-
-        start_times, end_times = self.get_branches_and_times_for_range(start_time=diff_from, end_time=diff_to)
-
-        filters = []
-        params = {}
-
-        for idx, branch_name in enumerate(start_times.keys()):
-            params[f"branch{idx}"] = branch_name
-            params[f"start_time{idx}"] = start_times[branch_name]
-            params[f"end_time{idx}"] = end_times[branch_name]
-
-        for rel in rel_labels:
-            filters_per_rel = []
-            for idx in range(len(start_times)):
-                filters_per_rel.extend(
-                    [
-                        f"""({rel}.branch = $branch{idx}
-                             AND {rel}.from >= $start_time{idx}
-                             AND {rel}.from <= $end_time{idx}
-                             AND ( r2.to is NULL or r2.to >= $end_time{idx}))""",
-                        f"""({rel}.branch = $branch{idx} AND {rel}.from >= $start_time{idx}
-                            AND {rel}.to <= $start_time{idx})""",
-                    ]
-                )
-
-            filters.append("(" + "\n OR ".join(filters_per_rel) + ")")
-
-        return filters, params
-
-    def get_query_filter_range(self, rel_label: list, start_time: Timestamp, end_time: Timestamp) -> tuple[list, dict]:
-        """
-        Generate a CYPHER Query filter to query a range of values in the graph between start_time and end_time."""
-
-        filters = []
-        params = {}
-
-        start_time = Timestamp(start_time)
-        end_time = Timestamp(end_time)
-
-        params["branches"] = self.get_branches_in_scope()
-        params["start_time"] = start_time.to_string()
-        params["end_time"] = end_time.to_string()
-
-        filters_per_rel = [
-            f"""({rel_label}.branch IN $branches AND {rel_label}.from >= $start_time
-                 AND {rel_label}.from <= $end_time AND {rel_label}.to IS NULL)""",
-            f"""({rel_label}.branch IN $branches AND (({rel_label}.from >= $start_time
-                 AND {rel_label}.from <= $end_time) OR ({rel_label}.to >= $start_time
-                 AND {rel_label}.to <= $end_time)))""",
-        ]
-
-        filters.append("(" + "\n OR ".join(filters_per_rel) + ")")
-
-        return filters, params
-
-    async def rebase(self, db: InfrahubDatabase, user_id: str = SYSTEM_USER_ID) -> None:
+    async def rebase(
+        self, db: InfrahubDatabase, at: Optional[Union[str, Timestamp]] = None, user_id: str = SYSTEM_USER_ID
+    ) -> None:
         """Rebase the current Branch with its origin branch"""
 
-        at = Timestamp()
+        at = Timestamp(at)
 
         await self.rebase_graph(db=db, at=at)
 

infrahub/core/branch/tasks.py

@@ -88,7 +88,7 @@ async def migrate_branch(branch: str, context: InfrahubContext, send_events: boo
 
         try:
             log.info(f"Running migrations for branch '{obj.name}'")
-            await migration_runner.run(db=db)
+            await migration_runner.run(db=db, at=Timestamp())
         except MigrationFailureError as exc:
             log.error(f"Failed to run migrations for branch '{obj.name}': {exc.errors}")
             raise
@@ -170,7 +170,8 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
         migrations = []
         async with lock.registry.global_graph_lock():
             async with db.start_transaction() as dbt:
-                await obj.rebase(db=dbt, user_id=context.account.account_id)
+                rebase_at = Timestamp()
+                await obj.rebase(db=dbt, user_id=context.account.account_id, at=rebase_at)
                 log.info("Branch successfully rebased")
 
             if obj.has_schema_changes:
@@ -199,6 +200,7 @@ async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool
                         previous_schema=schema_in_main_before,
                         migrations=migrations,
                         user_id=context.account.account_id,
+                        at=rebase_at,
                     )
                 )
                 for error in errors:
@@ -291,7 +293,8 @@ async def merge_branch(branch: str, context: InfrahubContext, proposed_change_id
                 diff_locker=DiffLocker(),
                 workflow=get_workflow(),
             )
-            branch_diff = await merger.merge()
+            merge_at = Timestamp()
+            branch_diff = await merger.merge(at=merge_at)
             await merger.update_schema()
 
         changelog_collector = DiffChangelogCollector(diff=branch_diff, branch=obj, db=db)
@@ -304,6 +307,7 @@ async def merge_branch(branch: str, context: InfrahubContext, proposed_change_id
                     previous_schema=merger.initial_source_schema,
                     migrations=merger.migrations,
                     user_id=context.account.account_id,
+                    at=merge_at,
                 )
             )
             for error in errors:

infrahub/core/diff/merger/merger.py

@@ -125,7 +125,11 @@ class DiffMerger:
                 )
                 await metadata_query.execute(db=self.db)
 
-        self.source_branch.branched_from = at.to_string()
+        # set the branched_from time to the previous microsecond to prevent duplicated
+        # relationships on the branch after the merge
+        branched_from = at.subtract(microseconds=1)
+
+        self.source_branch.branched_from = branched_from.to_string()
         await self.source_branch.save(db=self.db)
         registry.branch[self.source_branch.name] = self.source_branch
         return enriched_diff

infrahub/core/diff/model/path.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from dataclasses import asdict, dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING, Any
@@ -269,6 +270,27 @@ class EnrichedDiffRelationship(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.name)
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> EnrichedDiffRelationship:
+        """Custom deepcopy to handle circular references with EnrichedDiffNode.
+
+        The default deepcopy can fail because it may call __hash__ on a partially
+        constructed instance (before 'name' is set) when handling circular references
+        through the nodes -> relationships cycle.
+
+        This implementation ensures 'name' is set and the instance is registered
+        in memo before deepcopying other attributes that may have circular references.
+        """
+        new_obj = object.__new__(EnrichedDiffRelationship)
+        # Set the hashable attribute first (required for __hash__)
+        new_obj.name = self.name
+        # Register in memo BEFORE copying other attributes to handle circular refs
+        memo[id(self)] = new_obj
+        # Deepcopy all other attributes
+        for key, value in self.__dict__.items():
+            if key != "name":
+                setattr(new_obj, key, deepcopy(value, memo))
+        return new_obj
+
     @property
     def num_properties(self) -> int:
         return sum(r.num_properties for r in self.relationships)
@@ -327,6 +349,27 @@ class EnrichedDiffNode(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.identifier)
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> EnrichedDiffNode:
+        """Custom deepcopy to handle circular references with EnrichedDiffRelationship.
+
+        The default deepcopy can fail because it may call __hash__ on a partially
+        constructed instance (before 'identifier' is set) when handling circular references
+        through the relationships -> nodes cycle.
+
+        This implementation ensures 'identifier' is set and the instance is registered
+        in memo before deepcopying other attributes that may have circular references.
+        """
+        new_obj = object.__new__(EnrichedDiffNode)
+        # Set the hashable attribute first (required for __hash__)
+        new_obj.identifier = deepcopy(self.identifier, memo)
+        # Register in memo BEFORE copying other attributes to handle circular refs
+        memo[id(self)] = new_obj
+        # Deepcopy all other attributes
+        for key, value in self.__dict__.items():
+            if key != "identifier":
+                setattr(new_obj, key, deepcopy(value, memo))
+        return new_obj
+
     @property
     def uuid(self) -> str:
         return self.identifier.uuid

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 50
+GRAPH_VERSION = 55

infrahub/core/graph/index.py

@@ -13,6 +13,8 @@ node_indexes: list[IndexItem] = [
     IndexItem(name="rel_uuid", label="Relationship", properties=["uuid"], type=IndexType.RANGE),
     IndexItem(name="rel_identifier", label="Relationship", properties=["name"], type=IndexType.RANGE),
     IndexItem(name="attr_value_indexed", label="AttributeValueIndexed", properties=["value"], type=IndexType.RANGE),
+    # TEXT index for efficient CONTAINS/STARTS WITH/ENDS WITH searches on attribute values
+    IndexItem(name="attr_value_indexed_text", label="AttributeValueIndexed", properties=["value"], type=IndexType.TEXT),
     # diff indices
     IndexItem(name="diff_uuid", label="DiffRoot", properties=["uuid"], type=IndexType.TEXT),
     IndexItem(name="diff_node_uuid", label="DiffNode", properties=["uuid"], type=IndexType.TEXT),

infrahub/core/initialization.py

@@ -30,6 +30,7 @@ from infrahub.core.protocols import CoreAccount, CoreAccountGroup, CoreAccountRo
 from infrahub.core.root import Root
 from infrahub.core.schema import SchemaRoot, core_models, internal_schema
 from infrahub.core.schema.manager import SchemaManager
+from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.database.memgraph import IndexManagerMemgraph
 from infrahub.database.neo4j import IndexManagerNeo4j
@@ -527,7 +528,7 @@ async def first_time_initialization(db: InfrahubDatabase) -> None:
     schema_branch = registry.schema.register_schema(schema=schema, branch=default_branch.name)
     schema_branch.load_schema(schema=SchemaRoot(**core_models))
     schema_branch.process()
-    await registry.schema.load_schema_to_db(schema=schema_branch, branch=default_branch, db=db)
+    await registry.schema.load_schema_to_db(schema=schema_branch, branch=default_branch, db=db, at=Timestamp())
     registry.schema.set_schema_branch(name=default_branch.name, schema=schema_branch)
     default_branch.update_schema_hash()
     await default_branch.save(db=db)