infrahub-server 1.7.0b0__py3-none-any.whl → 1.7.1__py3-none-any.whl

infrahub/graphql/manager.py

@@ -598,7 +598,10 @@ class GraphQLSchemaManager:
                 required=False,
                 description="Human friendly identifier",
             ),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "display_label": graphene.String(required=False),
             "Meta": type("Meta", (object,), meta_attrs),
         }
@@ -1005,8 +1008,16 @@ class GraphQLSchemaManager:
         if not top_level:
             filters["isnull"] = graphene.Boolean()
 
+        if schema.display_label:
+            display_label_schema = schema.get_attribute("display_label")
+            filters.update(
+                get_attribute_type(kind=display_label_schema.kind).get_graphql_filters(
+                    name="display_label", include_properties=False, include_isnull=True
+                )
+            )
+
         if schema.human_friendly_id and top_level:
-            # HFID filter limited to top level because we can't filter on HFID for relationships (yet)
+            # NOTE: this can loosen to allow filtering at a non-top level once IFC-2110 is implemented
             filters["hfid"] = graphene.List(graphene.String)
 
         for attr in schema.attributes:
@@ -1201,7 +1212,10 @@ class GraphQLSchemaManager:
 
         main_attrs: dict[str, Any] = {
             "node": graphene.Field(base_interface, required=False),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "node_metadata": graphene.Field(node_metadata, required=True),
             "Meta": type("Meta", (object,), meta_attrs),
         }

infrahub/graphql/mutations/account.py

@@ -9,13 +9,13 @@ from infrahub.auth import AuthType
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.node import Node
+from infrahub.core.order import OrderModel
 from infrahub.core.protocols import CoreAccount, CoreNode, InternalAccountToken
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase, retry_db_transaction
 from infrahub.exceptions import NodeNotFoundError, PermissionDeniedError
 from infrahub.graphql.field_extractor import extract_graphql_fields
 
-from ..models import OrderModel
 from ..types import InfrahubObjectType
 
 if TYPE_CHECKING:

infrahub/graphql/order.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+
+from infrahub.core.order import OrderModel
+
+
+def deserialize_order_input(input_data: dict[str, Any] | None) -> OrderModel | None:
+    # Corresponds to infrahub.graphql.manager.OrderInput
+    if not input_data:
+        return None
+
+    order_model = OrderModel(**input_data)
+    return order_model

infrahub/graphql/queries/diff/tree.py

@@ -60,10 +60,10 @@ class ConflictDetails(ObjectType):
 
 
 class DiffSummaryCounts(ObjectType):
-    num_added = Int(required=False)
-    num_updated = Int(required=False)
-    num_removed = Int(required=False)
-    num_conflicts = Int(required=False)
+    num_added = Int(required=True)
+    num_updated = Int(required=True)
+    num_removed = Int(required=True)
+    num_conflicts = Int(required=True)
 
 
 class DiffProperty(ObjectType):
@@ -146,7 +146,7 @@ class DiffTreeSummary(DiffSummaryCounts):
     diff_branch = String(required=True)
     from_time = DateTime(required=True)
     to_time = DateTime(required=True)
-    num_unchanged = Int(required=False)
+    num_unchanged = Int(required=True)
     num_untracked_base_changes = Int(required=False)
     num_untracked_diff_changes = Int(required=False)
 

infrahub/graphql/queries/resource_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import contextlib
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from graphene import BigInt, Field, Float, Int, List, NonNull, ObjectType, String
 
@@ -129,18 +129,17 @@ class PoolAllocated(ObjectType):
 
             node_fields = edges.get("node", {})
 
-            nodes = []
-            for result in query.get_results():
-                child_node = result.get_node("child")
-                child_value_node = result.get_node("av")
-                node_id = str(child_node.get("uuid"))
-
-                child_ip_value = child_value_node.get("value")
-                kind = child_node.get("kind")
-                branch_name = str(result.get("branch"))
-
+            nodes: list[dict[str, dict[str, str | None]]] = []
+            for item in query.get_data():
                 nodes.append(
-                    {"node": {"id": node_id, "kind": kind, "branch": branch_name, "display_label": child_ip_value}}
+                    {
+                        "node": {
+                            "id": item.child_uuid,
+                            "kind": item.child_kind,
+                            "branch": item.branch,
+                            "display_label": item.ip_value,
+                        }
+                    }
                 )
 
             if "identifier" in node_fields:
@@ -152,19 +151,21 @@ class PoolAllocated(ObjectType):
                 identifier_query_class = identifier_query_map.get(pool.get_kind())
                 if not identifier_query_class:
                     raise ValidationError(input_value=f"This query doesn't get support {pool.get_kind()}")
-                identifier_query = await identifier_query_class.init(
-                    db=graphql_context.db, at=graphql_context.at, pool_id=pool_id, allocated=allocated_ids
+                identifier_query = cast(
+                    "IPAddressPoolGetIdentifiers | PrefixPoolGetIdentifiers",
+                    await identifier_query_class.init(
+                        db=graphql_context.db, at=graphql_context.at, pool_id=pool_id, allocated=allocated_ids
+                    ),
                 )
                 await identifier_query.execute(db=graphql_context.db)
 
-                reservations = {}
-                for result in identifier_query.get_results():
-                    reservation = result.get_rel("reservation")
-                    allocated = result.get_node("allocated")
-                    reservations[allocated.get("uuid")] = reservation.get("identifier")
+                reservations: dict[str, str] = {}
+                for identifier_item in identifier_query.get_data():
+                    reservations[identifier_item.allocated_uuid] = identifier_item.identifier
 
                 for node in nodes:
-                    node["node"]["identifier"] = reservations.get(node["node"]["id"])
+                    node_id = cast("str", node["node"]["id"])
+                    node["node"]["identifier"] = reservations.get(node_id)
 
             response["edges"] = nodes
 
@@ -284,13 +285,13 @@ async def resolve_number_pool_allocation(
     if "edges" in fields:
         await query.execute(db=db)
         edges = []
-        for entry in query.results:
+        for item in query.get_data():
             node = {
                 "node": {
-                    "id": entry.get_as_optional_type("id", str),
+                    "id": item.id,
                     "kind": pool.node.value,  # type: ignore[attr-defined]
-                    "branch": entry.get_as_optional_type("branch", str),
-                    "display_label": entry.get_as_optional_type("value", int),
+                    "branch": item.branch,
+                    "display_label": item.value,
                 }
             }
             edges.append(node)

infrahub/graphql/resolvers/ipam.py

@@ -16,10 +16,11 @@ from infrahub.core.node import Node
 from infrahub.core.protocols import BuiltinIPNamespace, BuiltinIPPrefix
 from infrahub.core.schema.generic_schema import GenericSchema
 from infrahub.exceptions import ValidationError
-from infrahub.graphql.models import OrderModel
 from infrahub.graphql.parser import extract_selection
 from infrahub.graphql.permissions import get_permissions
 
+from ..order import deserialize_order_input
+
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
@@ -322,7 +323,7 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
     if not isinstance(schema, GenericSchema) or schema.kind not in [InfrahubKind.IPADDRESS, InfrahubKind.IPPREFIX]:
         raise ValidationError(f"{schema.kind} is not {InfrahubKind.IPADDRESS} or {InfrahubKind.IPPREFIX}")
 
-    order_model = OrderModel.from_input(input_data=order)
+    order_model = deserialize_order_input(input_data=order)
     fields = await extract_selection(info=info, schema=schema)
     resolve_available = bool(kwargs.pop("include_available", False))
     kinds_to_filter: list[str] = kwargs.pop("kinds", [])  # type: ignore[assignment]
@@ -398,7 +399,6 @@ async def ipam_paginated_list_resolver(  # noqa: PLR0915
                 branch=graphql_context.branch,
                 limit=query_limit,
                 offset=offset,
-                account=graphql_context.account_session,
                 include_metadata=MetadataOptions.LINKED_NODES,
                 partial_match=partial_match,
                 order=order_model,

infrahub/graphql/resolvers/resolver.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any
 
 from graphql.type.definition import GraphQLNonNull
@@ -7,11 +8,12 @@ from opentelemetry import trace
 
 from infrahub.core.constants import BranchSupportType, InfrahubKind, RelationshipHierarchyDirection
 from infrahub.core.manager import NodeManager
+from infrahub.core.order import OrderModel
 from infrahub.exceptions import NodeNotFoundError
 from infrahub.graphql.field_extractor import extract_graphql_fields
 from infrahub.graphql.metadata import build_metadata_query_options
 
-from ..models import OrderModel
+from ..order import deserialize_order_input
 from ..parser import extract_selection
 from ..permissions import get_permissions
 
@@ -140,6 +142,45 @@ async def parent_field_name_resolver(parent: dict[str, dict], info: GraphQLResol
     return parent[info.field_name]
 
 
+def _transform_metadata_day_filters(filters: dict[str, Any]) -> dict[str, Any]:
+    """Transform metadata datetime filters with 00:00:00 time into day range filters.
+
+    When a filter like `node_metadata__created_at="2025-02-03T00:00:00"` has a time
+    of exactly midnight, transform it into __after and __before filters to match
+    the entire day (inclusive of midnight).
+
+    If __after or __before filters are already explicitly defined, they will not be
+    overwritten by the generated day range filters.
+    """
+    result = dict(filters)
+    metadata_datetime_fields = ("node_metadata__created_at", "node_metadata__updated_at")
+
+    for field in metadata_datetime_fields:
+        if field not in result:
+            continue
+        value = result[field]
+        if not isinstance(value, datetime):
+            continue
+        # Check if time is midnight (00:00:00)
+        if value.hour == 0 and value.minute == 0 and value.second == 0 and value.microsecond == 0:
+            # Remove the exact match filter
+            del result[field]
+            # Add __after filter with one microsecond before midnight to include objects at exactly midnight
+            # Skip if __after is already explicitly defined
+            after_key = f"{field}__after"
+            if after_key not in result:
+                one_microsecond_before = value - timedelta(microseconds=1)
+                result[after_key] = one_microsecond_before
+            # Add __before filter with next day (exclusive: <)
+            # Skip if __before is already explicitly defined
+            before_key = f"{field}__before"
+            if before_key not in result:
+                next_day = value + timedelta(days=1)
+                result[before_key] = next_day
+
+    return result
+
+
 @trace.get_tracer(__name__).start_as_current_span("default_paginated_list_resolver")
 async def default_paginated_list_resolver(
     root: dict,  # noqa: ARG001
@@ -156,7 +197,7 @@ async def default_paginated_list_resolver(
         else info.return_type.graphene_type._meta.schema
     )
 
-    order_model = OrderModel.from_input(input_data=order)
+    order_model = deserialize_order_input(input_data=order)
 
     fields = await extract_selection(info=info, schema=schema)
 
@@ -166,6 +207,7 @@ async def default_paginated_list_resolver(
         filters = {
             key: value for key, value in kwargs.items() if ("__" in key and value is not None) or key in ("ids", "hfid")
         }
+        filters = _transform_metadata_day_filters(filters)
 
         edges: dict[str, Any] = fields.get("edges", {})
         node_fields = edges.get("node", {})
@@ -203,7 +245,6 @@ async def default_paginated_list_resolver(
                 branch=graphql_context.branch,
                 limit=limit,
                 offset=offset,
-                account=graphql_context.account_session,
                 partial_match=partial_match,
                 order=order_model,
             )

infrahub/graphql/types/standard_node.py

@@ -13,12 +13,18 @@ if TYPE_CHECKING:
 
 
 class InfrahubObjectTypeOptions(ObjectTypeOptions):
-    model = None
+    model: type | None = None
 
 
 class InfrahubObjectType(ObjectType):
     @classmethod
-    def __init_subclass_with_meta__(cls, model=None, interfaces=(), _meta=None, **options) -> None:
+    def __init_subclass_with_meta__(
+        cls,
+        model: type | None = None,
+        interfaces: tuple[type, ...] = (),
+        _meta: InfrahubObjectTypeOptions | None = None,
+        **options: Any,
+    ) -> None:
         if not _meta:
             _meta = InfrahubObjectTypeOptions(cls)
 
@@ -38,14 +44,12 @@ class InfrahubObjectType(ObjectType):
                     filters=filters,
                     at=graphql_context.at,
                     branch=graphql_context.branch,
-                    account=graphql_context.account_session,
                     db=db,
                 )
             else:
                 objs = await cls._meta.model.get_list(
                     at=graphql_context.at,
                     branch=graphql_context.branch,
-                    account=graphql_context.account_session,
                     db=db,
                 )
 

infrahub/lock.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
 from prometheus_client import Histogram
+from redis import UsernamePasswordCredentialProvider
 from redis.asyncio.lock import Lock as GlobalLock
 
 from infrahub import config
@@ -275,10 +276,16 @@ class InfrahubLockRegistry:
     ) -> None:
         if config.SETTINGS.cache.enable and not local_only:
             if config.SETTINGS.cache.driver == config.CacheDriver.Redis:
+                credential_provider: UsernamePasswordCredentialProvider | None = None
+                if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+                    credential_provider = UsernamePasswordCredentialProvider(
+                        username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+                    )
                 self.connection = redis.Redis(
                     host=config.SETTINGS.cache.address,
                     port=config.SETTINGS.cache.service_port,
                     db=config.SETTINGS.cache.database,
+                    credential_provider=credential_provider,
                     ssl=config.SETTINGS.cache.tls_enabled,
                     ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
                     ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,

infrahub/menu/repository.py

@@ -6,7 +6,7 @@ from .models import MenuDict, MenuItemDefinition, MenuItemDict
 
 
 class MenuRepository:
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
 
     async def get_menu(self, nodes: dict[str, CoreMenuItem] | None = None) -> MenuDict:

infrahub/patch/queries/base.py

@@ -6,7 +6,7 @@ from ..models import PatchPlan
 
 
 class PatchQuery(ABC):
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
 
     @abstractmethod

infrahub/pools/number.py

@@ -37,14 +37,7 @@ class NumberUtilizationGetter:
         query = await NumberPoolGetAllocated.init(db=self.db, pool=self.pool, branch=self.branch, branch_agnostic=True)
         await query.execute(db=self.db)
 
-        self.used = [
-            UsedNumber(
-                number=result.get_as_type(label="value", return_type=int),
-                branch=result.get_as_type(label="branch", return_type=str),
-            )
-            for result in query.results
-            if result.get_as_optional_type(label="value", return_type=int) is not None
-        ]
+        self.used = [UsedNumber(number=item.value, branch=item.branch) for item in query.get_data()]
 
         self.used_default_branch = {entry.number for entry in self.used if entry.branch == registry.default_branch}
         used_branches = {entry.number for entry in self.used if entry.branch != registry.default_branch}

infrahub/profiles/node_applier.py

@@ -21,7 +21,7 @@ class NodeProfilesApplier:
     3. Profile priority determines which profile wins when multiple profiles set the same attribute
     """
 
-    def __init__(self, db: InfrahubDatabase, branch: Branch):
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
         self.db = db
         self.branch = branch
 

infrahub/profiles/queries/get_profile_data.py

@@ -34,7 +34,7 @@ class GetProfileDataQuery(Query):
         attr_names: list[str],
         relationship_filters: list[RelationshipFilter] | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         super().__init__(*args, **kwargs)
         self.profile_ids = profile_ids
         self.attr_names = attr_names

infrahub/proposed_change/action_checker.py

@@ -125,7 +125,7 @@ class ActionRule:
 
 
 class ActionRulesEvaluator:
-    def __init__(self, rules: list[ActionRule]):
+    def __init__(self, rules: list[ActionRule]) -> None:
         self.rules = rules
 
     async def evaluate(

infrahub/services/__init__.py

@@ -54,7 +54,7 @@ class InfrahubServices:
         message_bus: InfrahubMessageBus | None = None,
         workflow: InfrahubWorkflow | None = None,
         component: InfrahubComponent | None = None,
-    ):
+    ) -> None:
         """
         This method should not be called directly, use `new` instead for a proper initialization.
         """

infrahub/services/adapters/cache/nats.py

@@ -23,7 +23,7 @@ class NATSCache(InfrahubCache):
         jetstream: nats.js.JetStreamContext,
         kv: dict[int, nats.js.kv.KeyValue],
         kv_buckets: dict[str, KVTTL],
-    ):
+    ) -> None:
         self.connection = connection
         self.jetstream = jetstream
         self.kv = kv

infrahub/services/adapters/cache/redis.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
+from redis import UsernamePasswordCredentialProvider
 
 from infrahub import config
 from infrahub.services.adapters.cache import InfrahubCache
@@ -13,10 +14,16 @@ if TYPE_CHECKING:
 
 class RedisCache(InfrahubCache):
     def __init__(self) -> None:
+        credential_provider: UsernamePasswordCredentialProvider | None = None
+        if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+            credential_provider = UsernamePasswordCredentialProvider(
+                username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+            )
         self.connection = redis.Redis(
             host=config.SETTINGS.cache.address,
             port=config.SETTINGS.cache.service_port,
             db=config.SETTINGS.cache.database,
+            credential_provider=credential_provider,
             ssl=config.SETTINGS.cache.tls_enabled,
             ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
             ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,

infrahub/webhook/gather.py

@@ -13,5 +13,5 @@ from .models import WebhookTriggerDefinition
 @task(name="gather-trigger-webhook", task_run_name="Gather webhook triggers", cache_policy=NONE)
 async def gather_trigger_webhook(db: InfrahubDatabase) -> list[WebhookTriggerDefinition]:
     webhooks = await NodeManager.query(db=db, schema=CoreWebhook)
-    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks]
+    triggers = [WebhookTriggerDefinition.from_object(webhook) for webhook in webhooks if webhook.active.value]
     return triggers

infrahub/webhook/tasks.py

@@ -13,7 +13,7 @@ from prefect.logging import get_run_logger
 
 from infrahub.message_bus.types import KVTTL
 from infrahub.trigger.models import TriggerType
-from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.trigger.setup import gather_all_automations, setup_triggers_specific
 from infrahub.workers.dependencies import get_cache, get_client, get_database, get_http
 from infrahub.workflows.utils import add_tags
 
@@ -123,7 +123,7 @@ async def configure_webhook_all() -> None:
 
 @flow(name="webhook-setup-automation-one", flow_run_name="Configurate webhook for {webhook_name}")
 async def configure_webhook_one(
-    webhook_name: str,  # noqa: ARG001
+    webhook_name: str,
     event_data: dict,
 ) -> None:
     log = get_run_logger()
@@ -132,6 +132,24 @@ async def configure_webhook_one(
     trigger = WebhookTriggerDefinition.from_object(webhook)
 
     async with get_prefect_client(sync_client=False) as prefect_client:
+        all_automations = await gather_all_automations(client=prefect_client)
+        existing_automations = [
+            automation for automation in all_automations if automation.name == trigger.generate_name()
+        ]
+        existing_automation = existing_automations[0] if existing_automations else None
+
+        # If webhook is inactive, delete the automation if it exists
+        if not webhook.active.value:
+            if existing_automation:
+                await prefect_client.delete_automation(automation_id=existing_automation.id)
+                log.info(f"Automation {trigger.generate_name()} deleted (webhook disabled)")
+            else:
+                log.info(f"Webhook {webhook_name} is disabled, no automation to delete")
+
+            cache = await get_cache()
+            await cache.delete(key=f"webhook:{webhook.id}")
+            return
+
         # Query the deployment associated with the trigger to have its ID
         deployment_name = trigger.get_deployment_names()[0]
         deployment = await prefect_client.read_deployment_by_name(name=f"{deployment_name}/{deployment_name}")
@@ -144,9 +162,6 @@ async def configure_webhook_one(
             actions=[action.get(deployment.id) for action in trigger.actions],
         )
 
-        existing_automations = await prefect_client.read_automations_by_name(trigger.generate_name())
-        existing_automation = existing_automations[0] if existing_automations else None
-
         if existing_automation:
             await prefect_client.update_automation(automation_id=existing_automation.id, automation=automation)
             log.info(f"Automation {trigger.generate_name()} updated")
@@ -168,7 +183,8 @@ async def delete_webhook_automation(
     async with get_prefect_client(sync_client=False) as prefect_client:
         automation_name = WebhookTriggerDefinition.generate_name_from_id(id=webhook_id)
 
-        existing_automations = await prefect_client.read_automations_by_name(automation_name)
+        all_automations = await gather_all_automations(client=prefect_client)
+        existing_automations = [automation for automation in all_automations if automation.name == automation_name]
         existing_automation = existing_automations[0] if existing_automations else None
 
         if existing_automation:

infrahub_sdk/analyzer.py

@@ -30,10 +30,10 @@ class GraphQLOperation(BaseModel):
 
 
 class GraphQLQueryAnalyzer:
-    def __init__(self, query: str, schema: GraphQLSchema | None = None) -> None:
+    def __init__(self, query: str, schema: GraphQLSchema | None = None, document: DocumentNode | None = None) -> None:
         self.query: str = query
         self.schema: GraphQLSchema | None = schema
-        self.document: DocumentNode = parse(self.query)
+        self.document: DocumentNode = document or parse(self.query)
         self._fields: dict | None = None
 
     @property