infrahub-server 1.5.0b1__py3-none-any.whl → 1.5.1__py3-none-any.whl

infrahub/cli/dev.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import importlib
+import logging
+from pathlib import Path  # noqa: TC003
+from typing import TYPE_CHECKING
+
+import typer
+from graphql import parse, print_ast, print_schema
+from infrahub_sdk.async_typer import AsyncTyper
+from rich.logging import RichHandler
+
+from infrahub import config
+from infrahub.core.initialization import (
+    first_time_initialization,
+    initialization,
+)
+from infrahub.core.schema import SchemaRoot, core_models, internal_schema
+from infrahub.core.schema.schema_branch import SchemaBranch
+from infrahub.core.utils import delete_all_nodes
+from infrahub.graphql.manager import GraphQLSchemaManager
+from infrahub.graphql.schema_sort import sort_schema_ast
+from infrahub.log import get_logger
+
+if TYPE_CHECKING:
+    from infrahub.cli.context import CliContext
+
+app = AsyncTyper()
+
+
+@app.command(name="export-graphql-schema")
+async def export_graphql_schema(
+    ctx: typer.Context,  # noqa: ARG001
+    config_file: str = typer.Option("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+    out: Path = typer.Option("schema.graphql"),  # noqa: B008
+) -> None:
+    """Export the Core GraphQL schema to a file."""
+
+    config.load_and_exit(config_file_name=config_file)
+
+    schema = SchemaRoot(**internal_schema)
+    full_schema = schema.merge(schema=SchemaRoot(**core_models))
+
+    schema_branch = SchemaBranch(cache={}, name="default")
+    schema_branch.load_schema(schema=full_schema)
+
+    schema_branch.process()
+
+    gqlm = GraphQLSchemaManager(schema=schema_branch)
+    gql_schema = gqlm.generate()
+
+    schema_str = print_schema(gql_schema)
+    schema_ast = parse(schema_str)
+    sorted_schema_ast = sort_schema_ast(schema_ast)
+    sorted_schema_str = print_ast(sorted_schema_ast)
+
+    out.write_text(sorted_schema_str)
+
+
+@app.command(name="db-init")
+async def database_init(
+    ctx: typer.Context,
+    config_file: str = typer.Option(
+        "infrahub.toml", envvar="INFRAHUB_CONFIG", help="Location of the configuration file to use for Infrahub"
+    ),
+) -> None:
+    """Erase the content of the database and initialize it with the core schema."""
+
+    log = get_logger()
+
+    # --------------------------------------------------
+    # CLEANUP
+    #  - For now we delete everything in the database
+    #   TODO, if possible try to implement this in an idempotent way
+    # --------------------------------------------------
+
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+    async with dbdriver.start_transaction() as db:
+        log.info("Delete All Nodes")
+        await delete_all_nodes(db=db)
+        await first_time_initialization(db=db)
+
+    await dbdriver.close()
+
+
+@app.command(name="load-test-data")
+async def load_test_data(
+    ctx: typer.Context,
+    config_file: str = typer.Option(
+        "infrahub.toml", envvar="INFRAHUB_CONFIG", help="Location of the configuration file to use for Infrahub"
+    ),
+    dataset: str = "dataset01",
+) -> None:
+    """Load test data into the database from the `test_data` directory."""
+
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    async with dbdriver.start_session() as db:
+        await initialization(db=db)
+
+        log_level = "DEBUG"
+
+        FORMAT = "%(message)s"
+        logging.basicConfig(level=log_level, format=FORMAT, datefmt="[%X]", handlers=[RichHandler()])
+        logging.getLogger("infrahub")
+
+        dataset_module = importlib.import_module(f"infrahub.test_data.{dataset}")
+        await dataset_module.load_data(db=db)
+
+    await dbdriver.close()

infrahub/cli/tasks.py

@@ -3,9 +3,11 @@ import logging
 import typer
 from infrahub_sdk.async_typer import AsyncTyper
 from prefect.client.orchestration import get_client
+from prefect.client.schemas.objects import StateType
 
 from infrahub import config
 from infrahub.services.adapters.workflow.worker import WorkflowWorkerExecution
+from infrahub.task_manager.task import PrefectTask
 from infrahub.tasks.dummy import DUMMY_FLOW, DummyInput
 from infrahub.workflows.initialization import setup_task_manager
 from infrahub.workflows.models import WorkerPoolDefinition
@@ -50,3 +52,47 @@ async def execute(
             workflow=DUMMY_FLOW, parameters={"data": DummyInput(firstname="John", lastname="Doe")}
         )  # type: ignore[var-annotated]
         print(result)
+
+
+flush_app = AsyncTyper()
+
+app.add_typer(flush_app, name="flush")
+
+
+@flush_app.command()
+async def flow_runs(
+    ctx: typer.Context,  # noqa: ARG001
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+    days_to_keep: int = 30,
+    batch_size: int = 100,
+) -> None:
+    """Flush old task runs"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    await PrefectTask.delete_flow_runs(
+        days_to_keep=days_to_keep,
+        batch_size=batch_size,
+    )
+
+
+@flush_app.command()
+async def stale_runs(
+    ctx: typer.Context,  # noqa: ARG001
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+    days_to_keep: int = 2,
+    batch_size: int = 100,
+) -> None:
+    """Flush stale task runs"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    await PrefectTask.delete_flow_runs(
+        states=[StateType.RUNNING], delete=False, days_to_keep=days_to_keep, batch_size=batch_size
+    )

infrahub/cli/upgrade.py

@@ -8,13 +8,19 @@ import typer
 from deepdiff import DeepDiff
 from infrahub_sdk.async_typer import AsyncTyper
 from prefect.client.orchestration import get_client
-from rich import print as rprint
 
 from infrahub import config
-from infrahub.core.initialization import create_anonymous_role, create_default_account_groups, initialize_registry
+from infrahub.core.initialization import (
+    create_anonymous_role,
+    create_default_account_groups,
+    get_root_node,
+    initialize_registry,
+)
 from infrahub.core.manager import NodeManager
+from infrahub.core.migrations.shared import get_migration_console
 from infrahub.core.protocols import CoreAccount, CoreObjectPermission
 from infrahub.dependencies.registry import build_component_registry
+from infrahub.lock import initialize_lock
 from infrahub.menu.menu import default_menu
 from infrahub.menu.models import MenuDict
 from infrahub.menu.repository import MenuRepository
@@ -26,13 +32,22 @@ from infrahub.workflows.initialization import (
     setup_worker_pools,
 )
 
-from .db import initialize_internal_schema, migrate_database, update_core_schema
+from .db import (
+    detect_migration_to_run,
+    initialize_internal_schema,
+    mark_branches_needing_rebase,
+    migrate_database,
+    trigger_rebase_branches,
+    update_core_schema,
+)
 
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
+    from infrahub.core.branch.models import Branch
     from infrahub.database import InfrahubDatabase
 
 app = AsyncTyper()
+console = get_migration_console()
 
 
 @app.command(name="upgrade")
@@ -40,6 +55,10 @@ async def upgrade_cmd(
     ctx: typer.Context,
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
     check: bool = typer.Option(False, help="Check the state of the system without upgrading."),
+    rebase_branches: bool = typer.Option(False, help="Rebase and apply migrations to branches if required."),
+    interactive: bool = typer.Option(
+        False, help="Use interactive prompt to accept or deny rebase of individual branches."
+    ),
 ) -> None:
     """Upgrade Infrahub to the latest version."""
 
@@ -54,9 +73,12 @@ async def upgrade_cmd(
     dbdriver = await context.init_db(retry=1)
 
     await initialize_registry(db=dbdriver)
+    initialize_lock()
 
     build_component_registry()
 
+    root_node = await get_root_node(db=dbdriver)
+
     # NOTE add step to validate if the database and the task manager are reachable
 
     # -------------------------------------------
@@ -67,9 +89,14 @@ async def upgrade_cmd(
     # Upgrade Infrahub Database and Schema
     # -------------------------------------------
 
-    if not await migrate_database(db=dbdriver, initialize=False, check=check):
+    migrations = await detect_migration_to_run(current_graph_version=root_node.graph_version)
+    if check:
+        await dbdriver.close()
+        return
+
+    if not await migrate_database(db=dbdriver, initialize=False, migrations=migrations):
         # A migration failed, stop the upgrade process
-        rprint("Upgrade cancelled due to migration failure.")
+        console.log("Upgrade cancelled due to migration failure.")
         await dbdriver.close()
         return
 
@@ -91,6 +118,26 @@ async def upgrade_cmd(
         await setup_deployments(client=client)
         await trigger_configure_all()
 
+    # -------------------------------------------
+    # Perform branch rebase and apply migrations to them
+    # -------------------------------------------
+    branches = await mark_branches_needing_rebase(db=dbdriver)
+    plural = len(branches) != 1
+    get_migration_console().log(
+        f"Found {len(branches)} {'branches' if plural else 'branch'} that {'need' if plural else 'needs'} to be rebased"
+    )
+
+    if rebase_branches:
+        branches_to_rebase: list[Branch] = []
+        if not interactive:
+            branches_to_rebase = branches
+        else:
+            for branch in branches:
+                if typer.confirm(f"Rebase branch {branch.name}?"):
+                    branches_to_rebase.append(branch)
+
+        await trigger_rebase_branches(db=dbdriver, branches=branches_to_rebase)
+
     await dbdriver.close()
 
 
@@ -107,21 +154,21 @@ async def upgrade_menu(db: InfrahubDatabase) -> None:
     diff_menu = DeepDiff(menu_items.to_rest(), default_menu_dict.to_rest(), ignore_order=True)
 
     if not diff_menu:
-        rprint("Menu Up to date, nothing to update")
+        console.log("Menu Up to date, nothing to update")
         return
 
     await menu_repository.update_menu(existing_menu=menu_items, new_menu=default_menu_dict, menu_nodes=menu_nodes)
-    rprint("Menu has been updated")
+    console.log("Menu has been updated")
 
 
 async def upgrade_permissions(db: InfrahubDatabase) -> None:
     existing_permissions = await NodeManager.query(schema=CoreObjectPermission, db=db, limit=1)
     if existing_permissions:
-        rprint("Permissions Up to date, nothing to update")
+        console.log("Permissions Up to date, nothing to update")
         return
 
     await setup_permissions(db=db)
-    rprint("Permissions have been updated")
+    console.log("Permissions have been updated")
 
 
 async def setup_permissions(db: InfrahubDatabase) -> None:

infrahub/computed_attribute/tasks.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub_sdk.exceptions import URLNotFoundError
 from infrahub_sdk.protocols import CoreTransformPython
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
@@ -104,7 +105,7 @@ async def process_transform(
         )  # type: ignore[misc]
 
         data = await client.query_gql_query(
-            name=transform.query.peer.name.value,
+            name=transform.query.id,
             branch_name=branch_name,
             variables={"id": object_id},
             update_group=True,
@@ -177,12 +178,17 @@ async def computed_attribute_jinja2_update_value(
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")
         return
 
-    await client.execute_graphql(
-        query=UPDATE_ATTRIBUTE,
-        variables={"id": obj.node_id, "kind": node_kind, "attribute": attribute_name, "value": value},
-        branch_name=branch_name,
-    )
-    log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
+    try:
+        await client.execute_graphql(
+            query=UPDATE_ATTRIBUTE,
+            variables={"id": obj.node_id, "kind": node_kind, "attribute": attribute_name, "value": value},
+            branch_name=branch_name,
+        )
+        log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
+    except URLNotFoundError:
+        log.warning(
+            f"Update of computed attribute {node_kind}.{attribute_name} failed for branch {branch_name} (not found)"
+        )
 
 
 @flow(
@@ -229,7 +235,13 @@ async def process_jinja2(
 
         for id_filter in computed_macro.node_filters:
             query = attribute_graphql.render_graphql_query(query_filter=id_filter, filter_id=object_id)
-            response = await client.execute_graphql(query=query, branch_name=branch_name)
+            try:
+                response = await client.execute_graphql(query=query, branch_name=branch_name)
+            except URLNotFoundError:
+                log.warning(
+                    f"Process computed attributes for {computed_attribute_kind}.{computed_attribute_name} failed for branch {branch_name} (not found)"
+                )
+                return
             output = attribute_graphql.parse_response(response=response)
             found.extend(output)
 

infrahub/core/attribute.py

@@ -18,6 +18,7 @@ from infrahub.core.changelog.models import AttributeChangelog
 from infrahub.core.constants import NULL_VALUE, AttributeDBNodeType, BranchSupportType, RelationshipStatus
 from infrahub.core.property import FlagPropertyMixin, NodePropertyData, NodePropertyMixin
 from infrahub.core.query.attribute import (
+    AttributeClearNodePropertyQuery,
     AttributeGetQuery,
     AttributeUpdateFlagQuery,
     AttributeUpdateNodePropertyQuery,
@@ -491,6 +492,12 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 )
                 await query.execute(db=db)
 
+            if needs_clear:
+                query = await AttributeClearNodePropertyQuery.init(
+                    db=db, attr=self, at=update_at, prop_name=prop_name, prop_id=database_prop_id
+                )
+                await query.execute(db=db)
+
             # set the to time on the previously active edge
             rel = current_attr_result.get(f"rel_{prop_name}")
             if rel and rel.get("branch") == branch.name:
@@ -581,7 +588,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
 
         return value
 
-    async def from_graphql(self, data: dict, db: InfrahubDatabase) -> bool:
+    async def from_graphql(self, data: dict, db: InfrahubDatabase, process_pools: bool = True) -> bool:
         """Update attr from GraphQL payload"""
 
         changed = False
@@ -595,7 +602,8 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
                 changed = True
         elif "from_pool" in data:
             self.from_pool = data["from_pool"]
-            await self.node.handle_pool(db=db, attribute=self, errors=[])
+            if process_pools:
+                await self.node.handle_pool(db=db, attribute=self, errors=[])
             changed = True
 
         if changed and self.is_from_profile:

infrahub/core/branch/enums.py

@@ -4,5 +4,5 @@ from infrahub.utils import InfrahubStringEnum
 class BranchStatus(InfrahubStringEnum):
     OPEN = "OPEN"
     NEED_REBASE = "NEED_REBASE"
-    CLOSED = "CLOSED"
+    NEED_UPGRADE_REBASE = "NEED_UPGRADE_REBASE"
     DELETING = "DELETING"

infrahub/core/branch/models.py

@@ -6,9 +6,8 @@ from typing import TYPE_CHECKING, Any, Optional, Self, Union
 from pydantic import Field, field_validator
 
 from infrahub.core.branch.enums import BranchStatus
-from infrahub.core.constants import (
-    GLOBAL_BRANCH_NAME,
-)
+from infrahub.core.constants import GLOBAL_BRANCH_NAME
+from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.models import SchemaBranchHash  # noqa: TC001
 from infrahub.core.node.standard import StandardNode
 from infrahub.core.query import QueryType
@@ -46,6 +45,7 @@ class Branch(StandardNode):
     is_isolated: bool = True
     schema_changed_at: Optional[str] = None
     schema_hash: Optional[SchemaBranchHash] = None
+    graph_version: int | None = None
 
     _exclude_attrs: list[str] = ["id", "uuid", "owner"]
 
@@ -261,6 +261,10 @@ class Branch(StandardNode):
 
         return start, end
 
+    async def create(self, db: InfrahubDatabase) -> bool:
+        self.graph_version = GRAPH_VERSION
+        return await super().create(db=db)
+
     async def delete(self, db: InfrahubDatabase) -> None:
         if self.is_default:
             raise ValidationError(f"Unable to delete {self.name} it is the default branch.")

infrahub/core/branch/tasks.py

@@ -12,6 +12,7 @@ from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
 from infrahub.core import registry
 from infrahub.core.branch import Branch
+from infrahub.core.branch.enums import BranchStatus
 from infrahub.core.changelog.diff import DiffChangelogCollector, MigrationTracker
 from infrahub.core.constants import MutationAction
 from infrahub.core.diff.coordinator import DiffCoordinator
@@ -21,7 +22,10 @@ from infrahub.core.diff.merger.merger import DiffMerger
 from infrahub.core.diff.model.path import BranchTrackingId, EnrichedDiffRoot, EnrichedDiffRootMetadata
 from infrahub.core.diff.models import RequestDiffUpdate
 from infrahub.core.diff.repository.repository import DiffRepository
+from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.merge import BranchMerger
+from infrahub.core.migrations.exceptions import MigrationFailureError
+from infrahub.core.migrations.runner import MigrationRunner
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
 from infrahub.core.timestamp import Timestamp
@@ -29,7 +33,13 @@ from infrahub.core.validators.determiner import ConstraintValidatorDeterminer
 from infrahub.core.validators.models.validate_migration import SchemaValidateMigrationData
 from infrahub.core.validators.tasks import schema_validate_migrations
 from infrahub.dependencies.registry import get_component_registry
-from infrahub.events.branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
+from infrahub.events.branch_action import (
+    BranchCreatedEvent,
+    BranchDeletedEvent,
+    BranchMergedEvent,
+    BranchMigratedEvent,
+    BranchRebasedEvent,
+)
 from infrahub.events.models import EventMeta, InfrahubEvent
 from infrahub.events.node_action import get_node_event
 from infrahub.exceptions import BranchNotFoundError, ValidationError
@@ -49,8 +59,57 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags
 
 
+@flow(name="branch-migrate", flow_run_name="Apply migrations to branch {branch}")
+async def migrate_branch(branch: str, context: InfrahubContext, send_events: bool = True) -> None:
+    await add_tags(branches=[branch])
+
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        obj = await Branch.get_by_name(db=db, name=branch)
+
+        if obj.graph_version == GRAPH_VERSION:
+            log.info(f"Branch '{obj.name}' has graph version {obj.graph_version}, no migrations to apply")
+            return
+
+        migration_runner = MigrationRunner(branch=obj)
+        if not migration_runner.has_migrations():
+            log.info(f"No migrations detected for branch '{obj.name}'")
+            obj.graph_version = GRAPH_VERSION
+            await obj.save(db=db)
+            return
+
+        # Branch status will remain as so if the migration process fails
+        # This will help user to know that a branch is in an invalid state to be used properly and that actions need to be taken
+        if obj.status != BranchStatus.NEED_UPGRADE_REBASE:
+            obj.status = BranchStatus.NEED_UPGRADE_REBASE
+            await obj.save(db=db)
+
+        try:
+            log.info(f"Running migrations for branch '{obj.name}'")
+            await migration_runner.run(db=db)
+        except MigrationFailureError as exc:
+            log.error(f"Failed to run migrations for branch '{obj.name}': {exc.errors}")
+            raise
+
+        if obj.status == BranchStatus.NEED_UPGRADE_REBASE:
+            obj.status = BranchStatus.OPEN
+        obj.graph_version = GRAPH_VERSION
+        await obj.save(db=db)
+
+    if send_events:
+        event_service = await get_event_service()
+        await event_service.send(
+            BranchMigratedEvent(
+                branch_name=obj.name, branch_id=str(obj.uuid), meta=EventMeta(branch=obj, context=context)
+            )
+        )
+
+
 @flow(name="branch-rebase", flow_run_name="Rebase branch {branch}")
-async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa: PLR0915
+async def rebase_branch(branch: str, context: InfrahubContext, send_events: bool = True) -> None:  # noqa: PLR0915
+    workflow = get_workflow()
     database = await get_database()
     async with database.start_session() as db:
         log = get_run_logger()
@@ -69,7 +128,7 @@ async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa:
             diff_repository=diff_repository,
             source_branch=obj,
             diff_locker=DiffLocker(),
-            workflow=get_workflow(),
+            workflow=workflow,
         )
 
         enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
@@ -156,15 +215,17 @@ async def rebase_branch(branch: str, context: InfrahubContext) -> None:  # noqa:
             target_branch_name=registry.default_branch,
         )
         if ipam_node_details:
-            await get_workflow().submit_workflow(
+            await workflow.submit_workflow(
                 workflow=IPAM_RECONCILIATION,
                 context=context,
                 parameters={"branch": obj.name, "ipam_node_details": ipam_node_details},
             )
 
-    await get_workflow().submit_workflow(
-        workflow=DIFF_REFRESH_ALL, context=context, parameters={"branch_name": obj.name}
-    )
+    await migrate_branch(branch=branch, context=context, send_events=send_events)
+    await workflow.submit_workflow(workflow=DIFF_REFRESH_ALL, context=context, parameters={"branch_name": obj.name})
+
+    if not send_events:
+        return
 
     # -------------------------------------------------------------
     # Generate an event to indicate that a branch has been rebased

infrahub/core/constants/__init__.py

@@ -37,6 +37,7 @@ RESERVED_ATTR_REL_NAMES = [
     "rels",
     "save",
     "hfid",
+    "process_pools",
 ]
 
 RESERVED_ATTR_GEN_NAMES = ["type"]
@@ -50,6 +51,7 @@ class EventType(InfrahubStringEnum):
     BRANCH_CREATED = f"{EVENT_NAMESPACE}.branch.created"
     BRANCH_DELETED = f"{EVENT_NAMESPACE}.branch.deleted"
     BRANCH_MERGED = f"{EVENT_NAMESPACE}.branch.merged"
+    BRANCH_MIGRATED = f"{EVENT_NAMESPACE}.branch.migrated"
     BRANCH_REBASED = f"{EVENT_NAMESPACE}.branch.rebased"
 
     SCHEMA_UPDATED = f"{EVENT_NAMESPACE}.schema.updated"
@@ -99,6 +101,7 @@ class GlobalPermissions(InfrahubStringEnum):
     MANAGE_PERMISSIONS = "manage_permissions"
     MANAGE_REPOSITORIES = "manage_repositories"
     OVERRIDE_CONTEXT = "override_context"
+    UPDATE_OBJECT_HFID_DISPLAY_LABEL = "update_object_hfid_display_label"
 
 
 class PermissionAction(InfrahubStringEnum):

infrahub/core/diff/calculator.py

@@ -141,8 +141,8 @@ class DiffCalculator:
             to_time=to_time,
             previous_node_field_specifiers=previous_node_specifiers,
         )
-        node_limit = int(config.SETTINGS.database.query_size_limit / 10)
-        fields_limit = int(config.SETTINGS.database.query_size_limit / 3)
+        node_limit = max(int(config.SETTINGS.database.query_size_limit / 10), 1)
+        fields_limit = max(int(config.SETTINGS.database.query_size_limit / 3), 1)
         properties_limit = config.SETTINGS.database.query_size_limit
 
         calculation_request = DiffCalculationRequest(

infrahub/core/diff/query/artifact.py

@@ -201,4 +201,5 @@ CALL (target_node, definition_node){
             "target_checksum",
             "target_storage_id",
         ]
+        self.order_by = ["source_artifact.uuid", "target_node.uuid", "definition_node.uuid"]
         self.add_to_query(query=query)

infrahub/core/diff/query/delete_query.py

@@ -20,10 +20,14 @@ class EnrichedDiffDeleteQuery(Query):
             diff_filter = "WHERE d_root.uuid IN $diff_root_uuids"
 
         query = """
-        MATCH (d_root:DiffRoot)
-        %(diff_filter)s
-        OPTIONAL MATCH (d_root)-[*]->(diff_thing)
-        DETACH DELETE diff_thing
-        DETACH DELETE d_root
+MATCH (d_root:DiffRoot)
+%(diff_filter)s
+OPTIONAL MATCH (d_root)-[*]->(diff_thing)
+WITH DISTINCT d_root, diff_thing
+ORDER BY elementId(diff_thing)
+CALL (diff_thing) {
+    DETACH DELETE diff_thing
+} IN TRANSACTIONS
+DETACH DELETE d_root
         """ % {"diff_filter": diff_filter}
         self.add_to_query(query=query)

infrahub/core/diff/query/field_summary.py

@@ -62,6 +62,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         }
         """
         self.add_to_query(query=query)
+        self.order_by = ["kind"]
         self.return_labels = ["kind", "attr_names", "rel_names"]
 
     async def get_field_summaries(self) -> list[NodeDiffFieldSummary]: