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

infrahub/api/exceptions.py

@@ -4,12 +4,12 @@ from infrahub.exceptions import Error
 class QueryValidationError(Error):
     HTTP_CODE = 400
 
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         self.message = message
 
 
 class SchemaNotValidError(Error):
     HTTP_CODE = 422
 
-    def __init__(self, message: str):
+    def __init__(self, message: str) -> None:
         self.message = message

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/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
@@ -65,6 +66,7 @@ def get_timestamp_string() -> str:
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
     from infrahub.core.migrations.shared import MigrationTypes
+    from infrahub.core.root import Root
     from infrahub.database import InfrahubDatabase
     from infrahub.database.index import IndexManagerBase
 
@@ -93,12 +95,40 @@ def callback() -> None:
     """
 
 
+async def do_migrate(
+    db: InfrahubDatabase,
+    root_node: Root,
+    check: bool = False,
+    migration_number: int | None = None,
+) -> None:
+    """Core migration logic that can be called independently of CLI.
+
+    Args:
+        db: The database connection.
+        root_node: The root node containing the current graph version.
+        check: If True, only check which migrations need to run without applying them.
+        migration_number: If provided, run only this specific migration.
+    """
+    migrations = await detect_migration_to_run(
+        current_graph_version=root_node.graph_version, migration_number=migration_number
+    )
+
+    if check or not migrations:
+        return
+
+    await migrate_database(
+        db=db, migrations=migrations, initialize=True, update_graph_version=(migration_number is None)
+    )
+
+
 @app.command(name="migrate")
 async def migrate_cmd(
     ctx: typer.Context,
     check: bool = typer.Option(False, help="Check the state of the database without applying the migrations."),
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
-    migration_number: int | None = typer.Option(None, help="Apply a specific migration by number"),
+    migration_number: int | None = typer.Option(
+        None, help="Apply a specific migration by number, regardless of current database version"
+    ),
 ) -> None:
     """Check the current format of the internal graph and apply the necessary migrations"""
     logging.getLogger("infrahub").setLevel(logging.WARNING)
@@ -111,14 +141,7 @@ async def migrate_cmd(
     dbdriver = await context.init_db(retry=1)
 
     root_node = await get_root_node(db=dbdriver)
-    migrations = await detect_migration_to_run(
-        current_graph_version=root_node.graph_version, migration_number=migration_number
-    )
-
-    if check or not migrations:
-        return
-
-    await migrate_database(db=dbdriver, migrations=migrations, initialize=True)
+    await do_migrate(db=dbdriver, root_node=root_node, check=check, migration_number=migration_number)
 
     await dbdriver.close()
 
@@ -292,18 +315,17 @@ async def detect_migration_to_run(
         migration = get_migration_by_number(migration_number)
         migrations.append(migration)
         if current_graph_version > migration.minimum_version:
+            get_migration_console().log(f"Migration {migration_number} will be re-applied.")
+        else:
             get_migration_console().log(
-                f"Migration {migration_number} already applied. To apply again, run the command without the --check flag."
+                f"Migration {migration_number} needs to be applied. Run `infrahub db migrate` to apply all outstanding migrations."
             )
-            return []
-        get_migration_console().log(
-            f"Migration {migration_number} needs to be applied. Run `infrahub db migrate` to apply all outstanding migrations."
-        )
-    else:
-        migrations.extend(await get_graph_migrations(current_graph_version=current_graph_version))
-        if not migrations:
-            get_migration_console().log(f"Database up-to-date (v{current_graph_version}), no migration to execute.")
-            return []
+            return migrations
+
+    migrations.extend(await get_graph_migrations(current_graph_version=current_graph_version))
+    if not migrations:
+        get_migration_console().log(f"Database up-to-date (v{current_graph_version}), no migration to execute.")
+        return []
 
     get_migration_console().log(
         f"Database needs to be updated (v{current_graph_version} -> v{GRAPH_VERSION}), {len(migrations)} migrations pending"
@@ -312,7 +334,10 @@ async def detect_migration_to_run(
 
 
 async def migrate_database(
-    db: InfrahubDatabase, migrations: Sequence[MigrationTypes], initialize: bool = False
+    db: InfrahubDatabase,
+    migrations: Sequence[MigrationTypes],
+    initialize: bool = False,
+    update_graph_version: bool = True,
 ) -> bool:
     """Apply the latest migrations to the database, this function will print the status directly in the console.
 
@@ -322,6 +347,7 @@ async def migrate_database(
         db: The database object.
         migrations: Sequence of migrations to apply.
         initialize: Whether to initialize the registry before running migrations.
+        update_graph_version: Whether to update the graph version after each migration.
     """
     if not migrations:
         return True
@@ -332,15 +358,16 @@ 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:
             validation_result = await migration.validate_migration(db=db)
             if validation_result.success:
                 get_migration_console().log(f"Migration: {migration.name} {SUCCESS_BADGE}")
-                root_node.graph_version = migration.minimum_version + 1
-                await root_node.save(db=db)
+                if update_graph_version:
+                    root_node.graph_version = migration.minimum_version + 1
+                    await root_node.save(db=db)
 
         if not execution_result.success or (validation_result and not validation_result.success):
             get_migration_console().log(f"Migration: {migration.name} {FAILED_BADGE}")
@@ -476,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,
@@ -484,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(
@@ -501,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/core/account.py

@@ -54,11 +54,15 @@ class AccountGlobalPermissionQuery(Query):
     name: str = "account_global_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(self, account_id: str, **kwargs: Any):
+    def __init__(
+        self,
+        account_id: str,
+        branch: Branch | None = None,
+        branch_agnostic: bool = False,
+    ) -> None:
+        super().__init__(branch=branch, branch_agnostic=branch_agnostic)
         self.account_id = account_id
-        super().__init__(**kwargs)
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["account_id"] = self.account_id
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
@@ -66,7 +70,6 @@ class AccountGlobalPermissionQuery(Query):
         )
         self.params.update(branch_params)
 
-        # ruff: noqa: E501
         query = """
         MATCH (account:%(generic_account_node)s)
         WHERE account.uuid = $account_id
@@ -164,7 +167,7 @@ class AccountObjectPermissionQuery(Query):
     name: str = "account_object_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(self, account_id: str, **kwargs: Any):
+    def __init__(self, account_id: str, **kwargs: Any) -> None:
         self.account_id = account_id
         super().__init__(**kwargs)
 
@@ -293,7 +296,7 @@ class AccountObjectPermissionQuery(Query):
 
 
 async def fetch_permissions(account_id: str, db: InfrahubDatabase, branch: Branch) -> AssignedPermissions:
-    query1 = await AccountGlobalPermissionQuery.init(db=db, branch=branch, account_id=account_id, branch_agnostic=True)
+    query1 = AccountGlobalPermissionQuery(branch=branch, account_id=account_id, branch_agnostic=True)
     await query1.execute(db=db)
     global_permissions = query1.get_permissions()
 
@@ -308,7 +311,7 @@ class AccountRoleGlobalPermissionQuery(Query):
     name: str = "account_role_global_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(self, role_id: str, **kwargs: Any):
+    def __init__(self, role_id: str, **kwargs: Any) -> None:
         self.role_id = role_id
         super().__init__(**kwargs)
 
@@ -394,7 +397,7 @@ class AccountRoleObjectPermissionQuery(Query):
     name: str = "account_role_object_permissions"
     type: QueryType = QueryType.READ
 
-    def __init__(self, role_id: str, **kwargs: Any):
+    def __init__(self, role_id: str, **kwargs: Any) -> None:
         self.role_id = role_id
         super().__init__(**kwargs)
 
@@ -515,7 +518,7 @@ class AccountTokenValidateQuery(Query):
     name: str = "account_token_validate"
     type: QueryType = QueryType.READ
 
-    def __init__(self, token: str, **kwargs: Any):
+    def __init__(self, token: str, **kwargs: Any) -> None:
         self.token = token
         super().__init__(**kwargs)
 

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/branch_differ.py

@@ -41,7 +41,7 @@ class BranchDiffer:
         diff_to: str | Timestamp | None = None,
         db: InfrahubDatabase | None = None,
         service: InfrahubServices | None = None,
-    ):
+    ) -> None:
         """_summary_
 
         Args:

infrahub/core/diff/conflict_transferer.py

@@ -9,7 +9,7 @@ from .model.path import (
 
 
 class DiffConflictTransferer:
-    def __init__(self, diff_combiner: DiffCombiner):
+    def __init__(self, diff_combiner: DiffCombiner) -> None:
         self.diff_combiner = diff_combiner
 
     async def transfer(self, earlier: EnrichedDiffRoot, later: EnrichedDiffRoot) -> None:

infrahub/core/diff/data_check_synchronizer.py

@@ -29,7 +29,7 @@ class DiffDataCheckSynchronizer:
         conflicts_extractor: DiffConflictsExtractor,
         conflict_recorder: ObjectConflictValidatorRecorder,
         diff_repository: DiffRepository,
-    ):
+    ) -> None:
         self.db = db
         self.conflicts_extractor = conflicts_extractor
         self.conflict_recorder = conflict_recorder

infrahub/core/diff/enricher/cardinality_one.py

@@ -31,7 +31,7 @@ class DiffCardinalityOneEnricher(DiffEnricherInterface):
      - changes to properties (IS_PROTECTED, etc) of a cardinality=one relationship are consolidated as well
     """
 
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
         self._node_schema_map: dict[str, MainSchemaTypes] = {}
 

infrahub/core/diff/enricher/hierarchy.py

@@ -24,7 +24,7 @@ log = get_logger()
 class DiffHierarchyEnricher(DiffEnricherInterface):
     """Add hierarchy and parent/component nodes to diff even if the higher-level nodes are unchanged"""
 
-    def __init__(self, db: InfrahubDatabase, parent_adder: DiffParentNodeAdder):
+    def __init__(self, db: InfrahubDatabase, parent_adder: DiffParentNodeAdder) -> None:
         self.db = db
         self.parent_adder = parent_adder
 

infrahub/core/diff/enricher/labels.py

@@ -35,7 +35,7 @@ class DisplayLabelRequest:
 class DiffLabelsEnricher(DiffEnricherInterface):
     """Add display labels for nodes and labels for relationships"""
 
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
         self._base_branch_name: str | None = None
         self._diff_branch_name: str | None = None

infrahub/core/diff/merger/merger.py

@@ -36,7 +36,7 @@ class DiffMerger:
         destination_branch: Branch,
         diff_repository: DiffRepository,
         serializer: DiffMergeSerializer,
-    ):
+    ) -> None:
         self.source_branch = source_branch
         self.destination_branch = destination_branch
         self.db = db
@@ -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/repository/repository.py

@@ -49,7 +49,9 @@ log = get_logger()
 
 
 class DiffRepository:
-    def __init__(self, db: InfrahubDatabase, deserializer: EnrichedDiffDeserializer, max_save_batch_size: int = 1000):
+    def __init__(
+        self, db: InfrahubDatabase, deserializer: EnrichedDiffDeserializer, max_save_batch_size: int = 1000
+    ) -> None:
         self.db = db
         self.deserializer = deserializer
         self.max_save_batch_size = max_save_batch_size

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 50
+GRAPH_VERSION = 51

infrahub/core/graph/constraints.py

@@ -165,7 +165,7 @@ class ConstraintManagerBase:
     constraint_node_class: Optional[type[ConstraintItem]] = ConstraintItem
     constraint_rel_class: Optional[type[ConstraintItem]] = ConstraintItem
 
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase) -> None:
         self.db = db
 
         self.nodes: list[ConstraintItem] = []

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)

infrahub/core/ipam/reconciler.py

@@ -101,16 +101,18 @@ class IpamReconciler:
         )
         await query.execute(db=self.db)
 
-        ip_node_uuid = query.get_ip_node_uuid()
-        if not ip_node_uuid:
+        data = query.get_data()
+        if not data or not data.ip_node_uuid:
             node_type = InfrahubKind.IPPREFIX
             if isinstance(ip_value, ipaddress.IPv6Interface | ipaddress.IPv4Interface):
                 node_type = InfrahubKind.IPADDRESS
             raise NodeNotFoundError(node_type=node_type, identifier=str(ip_value))
-        current_parent_uuid = query.get_current_parent_uuid()
-        calculated_parent_uuid = query.get_calculated_parent_uuid()
-        current_children_uuids = set(query.get_current_children_uuids())
-        calculated_children_uuids = set(query.get_calculated_children_uuids())
+
+        ip_node_uuid = data.ip_node_uuid
+        current_parent_uuid = data.current_parent_uuid
+        calculated_parent_uuid = data.calculated_parent_uuid
+        current_children_uuids = set(data.current_children_uuids)
+        calculated_children_uuids = set(data.calculated_children_uuids)
 
         all_uuids: set[str] = set()
         all_uuids = (all_uuids | {ip_node_uuid}) if ip_node_uuid else all_uuids