infrahub-server 1.1.5__tar.gz → 1.1.7__tar.gz

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.1.5
+Version: 1.1.7
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only
@@ -58,16 +58,46 @@ Project-URL: Documentation, https://docs.infrahub.app/
 Project-URL: Repository, https://github.com/opsmill/infrahub
 Description-Content-Type: text/markdown
 
-<!-- markdownlint-disable -->
-![Infrahub Logo](docs/static/img/infrahub-hori.svg)
-<!-- markdownlint-restore -->
+<h1 align="center">
+  <a href=""><img src="docs/static/img/infrahub-hori.svg" alt="Infrahub" width="350"></a>
+</h1>
+<h3 align="center">Simplify Infrastructure Automation</h2>
 
-# Infrahub
+<p align="center">
+<a href="https://www.linkedin.com/company/opsmill">
+<img src="https://img.shields.io/badge/linkedin-blue?logo=linkedin"/>
+</a>
+<a href="https://discord.gg/opsmill">
+<img src="https://img.shields.io/badge/Discord-7289DA?&logo=discord&logoColor=white"/>
+</a>
+</p>
 
-Infrahub from [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run. Infrahub offers a central hub to manage the data, templates and playbooks that powers your infrastructure by combining the version control and branch management capabilities of Git with the flexible data model and UI of a graph database.
+Infrahub from [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run. Infrahub offers a central hub to manage the data, templates and playbooks that powers your infrastructure by combining the version control and branch management capabilities similar to Git with the flexible data model and UI of a graph database.
+
+If you just want to try Infrahub out, you can use our [Always-On Sandbox](https://demo.infrahub.app/) to get started.
 
 ![infrahub screenshot](docs/docs/media/infrahub-readme.gif)
 
+## Why Use Infrahub?
+
+**Unified Source of Truth** - Infrahub is a single source of truth for all your infrastructure and network data. It provides a unified view of your infrastructure, allowing you to manage your infrastructure in a more efficient and effective way. Infrahub allows unidirectional and bi-directional [data synchronization](https://docs.infrahub.app/sync/sync/) between other internal systems and Infrahub. The data can be accessed via WebUI, API and SDK, along with SSO and RBAC for access control.
+
+**Flexible Schema** - Infrahub provides a flexible schema for your infrastructure data and related business information, allowing you to define your own data model and customize it to your needs. Get started quickly with our [schema library](https://github.com/opsmill/schema-library) or build your own.
+
+**Version Control** - Infrahub provides a version control system for your infrastructure data, allowing you to track changes and revert to previous versions if needed. Immutable history of all changes to the data and artifacts is maintained, allowing you to audit and review changes to your infrastructure.
+
+**CI Pipeline and Validation** - Infrahub provides a CI pipeline and validation system for your infrastructure data, allowing you to ensure that your infrastructure is always in a valid state. Infrahub was designed with infrastructure-as-code workflows in mind, removing fragility and complexity of combining together multiple tools and projects to achieve the same goal.
+
+## Infrahub Use Cases
+
+**Service Catalog** - Infrahub acts as the underlying system to provide infrastructure-as-a-service, allowing you to manage your services and lifecycle them as the services evolve.
+
+**Infrastructure Automation** - Provide infrastructure and network automation workflows with Infrahub rendering configurations and artifacts via Jinja2 and python,then passing to deployment tools such as [Nornir](https://www.opsmill.com/simplifying-network-automation-workflows-with-infrahub-nornir-and-jinja2/), [Ansible](https://docs.infrahub.app/ansible/ansible/), Terraform, or vendor-specific tools.
+
+**Inventory Management** - Infrahub serves as a centralized inventory system for your infrastructure, allowing you to manage your inventory and track changes to your infrastructure. It provides a WebUI and API for other teams to self-service the information needed to allow the organization to operate.
+
+**DCIM and IPAM** - Infrahub provides centralized DCIM and IPAM systems for your infrastructure, capable of handling complex cases such as overlapping IP addresses and VLANs, automation-friendly, branch-aware allocation of resources via Infrahub's [Resource Manager](https://docs.infrahub.app/python-sdk/guides/resource-manager), and more.
+
 ## Quick Start
 
 [Always-On Sandbox](https://demo.infrahub.app/) - Instantly login to the UI of a demo environment of Infrahub with sample data pre-loaded.
@@ -94,7 +124,11 @@ If you need help, support for the community version of Infrahub is provided on [
 
 ## Contributing
 
-[View our CONTRIBUTING](./CONTRIBUTING.md) policy to get started on contributing to Infrahub.
+To help our community with the creation of contributions, please view our [CONTRIBUTING](./CONTRIBUTING.md) page.
+
+<a  href="https://github.com/opsmill/infrahub/graphs/contributors">
+<img  src="https://contrib.rocks/image?repo=opsmill/infrahub" />
+</a>
 
 ## Security
 

infrahub_server-1.1.7/README.md

@@ -0,0 +1,75 @@
+<h1 align="center">
+  <a href=""><img src="docs/static/img/infrahub-hori.svg" alt="Infrahub" width="350"></a>
+</h1>
+<h3 align="center">Simplify Infrastructure Automation</h2>
+
+<p align="center">
+<a href="https://www.linkedin.com/company/opsmill">
+<img src="https://img.shields.io/badge/linkedin-blue?logo=linkedin"/>
+</a>
+<a href="https://discord.gg/opsmill">
+<img src="https://img.shields.io/badge/Discord-7289DA?&logo=discord&logoColor=white"/>
+</a>
+</p>
+
+Infrahub from [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run. Infrahub offers a central hub to manage the data, templates and playbooks that powers your infrastructure by combining the version control and branch management capabilities similar to Git with the flexible data model and UI of a graph database.
+
+If you just want to try Infrahub out, you can use our [Always-On Sandbox](https://demo.infrahub.app/) to get started.
+
+![infrahub screenshot](docs/docs/media/infrahub-readme.gif)
+
+## Why Use Infrahub?
+
+**Unified Source of Truth** - Infrahub is a single source of truth for all your infrastructure and network data. It provides a unified view of your infrastructure, allowing you to manage your infrastructure in a more efficient and effective way. Infrahub allows unidirectional and bi-directional [data synchronization](https://docs.infrahub.app/sync/sync/) between other internal systems and Infrahub. The data can be accessed via WebUI, API and SDK, along with SSO and RBAC for access control.
+
+**Flexible Schema** - Infrahub provides a flexible schema for your infrastructure data and related business information, allowing you to define your own data model and customize it to your needs. Get started quickly with our [schema library](https://github.com/opsmill/schema-library) or build your own.
+
+**Version Control** - Infrahub provides a version control system for your infrastructure data, allowing you to track changes and revert to previous versions if needed. Immutable history of all changes to the data and artifacts is maintained, allowing you to audit and review changes to your infrastructure.
+
+**CI Pipeline and Validation** - Infrahub provides a CI pipeline and validation system for your infrastructure data, allowing you to ensure that your infrastructure is always in a valid state. Infrahub was designed with infrastructure-as-code workflows in mind, removing fragility and complexity of combining together multiple tools and projects to achieve the same goal.
+
+## Infrahub Use Cases
+
+**Service Catalog** - Infrahub acts as the underlying system to provide infrastructure-as-a-service, allowing you to manage your services and lifecycle them as the services evolve.
+
+**Infrastructure Automation** - Provide infrastructure and network automation workflows with Infrahub rendering configurations and artifacts via Jinja2 and python,then passing to deployment tools such as [Nornir](https://www.opsmill.com/simplifying-network-automation-workflows-with-infrahub-nornir-and-jinja2/), [Ansible](https://docs.infrahub.app/ansible/ansible/), Terraform, or vendor-specific tools.
+
+**Inventory Management** - Infrahub serves as a centralized inventory system for your infrastructure, allowing you to manage your inventory and track changes to your infrastructure. It provides a WebUI and API for other teams to self-service the information needed to allow the organization to operate.
+
+**DCIM and IPAM** - Infrahub provides centralized DCIM and IPAM systems for your infrastructure, capable of handling complex cases such as overlapping IP addresses and VLANs, automation-friendly, branch-aware allocation of resources via Infrahub's [Resource Manager](https://docs.infrahub.app/python-sdk/guides/resource-manager), and more.
+
+## Quick Start
+
+[Always-On Sandbox](https://demo.infrahub.app/) - Instantly login to the UI of a demo environment of Infrahub with sample data pre-loaded.
+
+[Getting Started Environment & Tutorial](https://opsmill.instruqt.com/pages/labs) - It spins up an instance of Infrahub on our cloud, provides a browser, terminal, code editor and walks you through the basic concepts:
+
+- Branching and version control
+- Flexible schema
+- Unified storage
+
+For longer term tests, you can deploy a local instance of Infrahub by referring to our guide: [Installing Infrahub](https://docs.infrahub.app/guides/installation)
+
+## Documentation
+
+If you'd like to learn more about Infrahub, please refer to the following resources:
+
+- [Infrahub Overview](https://docs.infrahub.app/overview/)
+- [Infrahub Documentation](https://docs.infrahub.app/)
+- [FAQ](https://docs.infrahub.app/faq/)
+
+## Support and Community
+
+If you need help, support for the community version of Infrahub is provided on [![Join our Discord server](https://img.shields.io/badge/Discord-7289DA?logo=discord&logoColor=white)](https://discord.gg/opsmill) or via [filing an issue on GitHub](https://github.com/opsmill/infrahub/issues).
+
+## Contributing
+
+To help our community with the creation of contributions, please view our [CONTRIBUTING](./CONTRIBUTING.md) page.
+
+<a  href="https://github.com/opsmill/infrahub/graphs/contributors">
+<img  src="https://contrib.rocks/image?repo=opsmill/infrahub" />
+</a>
+
+## Security
+
+[View our SECURITY](https://github.com/opsmill/infrahub?tab=security-ov-file) policy to find the latest information.

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/api/oidc.py

@@ -210,6 +210,7 @@ async def _get_id_token_groups(
         algorithms=oidc_config.id_token_signing_alg_values_supported,
         audience=client_id,
         issuer=str(oidc_config.issuer),
+        options={"verify_signature": False, "verify_aud": False, "verify_iss": False},
     )
 
     return decoded_token.get("groups", [])

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/core/attribute.py

@@ -470,6 +470,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         related_node_ids: Optional[set] = None,
         filter_sensitive: bool = False,
         permissions: Optional[dict] = None,
+        include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for this attribute."""
         # pylint: disable=too-many-branches
@@ -480,7 +481,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             field_names = fields.keys()
         else:
             # REMOVED updated_at for now, need to investigate further how it's being used today
-            field_names = ["__typename", "value"] + self._node_properties + self._flag_properties
+            field_names = ["__typename", "value"]
+            if include_properties:
+                field_names += self._node_properties + self._flag_properties
 
         for field_name in field_names:
             if field_name == "updated_at":

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/core/branch/tasks.py

@@ -70,14 +70,17 @@ async def rebase_branch(branch: str) -> None:
             service=service,
         )
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
-        enriched_diff = await diff_coordinator.update_branch_diff_and_return(base_branch=base_branch, diff_branch=obj)
-        if enriched_diff.get_all_conflicts():
+        enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
+        async for _ in diff_repository.get_all_conflicts_for_diff(
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
+        ):
+            # if there are any conflicts, raise the error
             raise ValidationError(
                 f"Branch {obj.name} contains conflicts with the default branch that must be addressed."
                 " Please review the diff for details and manually update the conflicts before rebasing."
             )
         node_diff_field_summaries = await diff_repository.get_node_field_summaries(
-            diff_branch_name=enriched_diff.diff_branch_name, diff_id=enriched_diff.uuid
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
         )
 
         candidate_schema = merger.get_candidate_schema()
@@ -219,7 +222,7 @@ async def merge_branch(branch: str) -> None:
         # remove tracking ID from the diff because there is no diff after the merge
         # -------------------------------------------------------------
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
-        await diff_repository.drop_tracking_ids(tracking_ids=[BranchTrackingId(name=obj.name)])
+        await diff_repository.mark_tracking_ids_merged(tracking_ids=[BranchTrackingId(name=obj.name)])
 
         # -------------------------------------------------------------
         # Generate an event to indicate that a branch has been merged

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/core/diff/calculator.py

@@ -4,7 +4,12 @@ from infrahub import config
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.diff.query_parser import DiffQueryParser
-from infrahub.core.query.diff import DiffAllPathsQuery, DiffCalculationQuery, DiffFieldPathsQuery, DiffNodePathsQuery
+from infrahub.core.query.diff import (
+    DiffCalculationQuery,
+    DiffFieldPathsQuery,
+    DiffNodePathsQuery,
+    DiffPropertyPathsQuery,
+)
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.log import get_logger
@@ -86,6 +91,7 @@ class DiffCalculator:
         )
         node_limit = int(config.SETTINGS.database.query_size_limit / 10)
         fields_limit = int(config.SETTINGS.database.query_size_limit / 3)
+        properties_limit = int(config.SETTINGS.database.query_size_limit)
 
         calculation_request = DiffCalculationRequest(
             base_branch=base_branch,
@@ -113,21 +119,14 @@ class DiffCalculator:
         )
         log.info("Diff field-level calculation queries for branch complete")
 
-        branch_diff_query = await DiffAllPathsQuery.init(
-            db=self.db,
-            branch=diff_branch,
-            base_branch=base_branch,
-            diff_branch_from_time=diff_branch_from_time,
-            diff_from=from_time,
-            diff_to=to_time,
+        log.info("Beginning diff property-level calculation queries for branch")
+        await self._run_diff_calculation_query(
+            diff_parser=diff_parser,
+            query_class=DiffPropertyPathsQuery,
+            calculation_request=calculation_request,
+            limit=properties_limit,
         )
-        log.info("Beginning diff calculation query for branch")
-        await branch_diff_query.execute(db=self.db)
-        log.info("Diff calculation query for branch complete")
-        log.info("Reading results of query for branch")
-        for query_result in branch_diff_query.get_results():
-            diff_parser.read_result(query_result=query_result)
-        log.info("Results of query for branch read")
+        log.info("Diff property-level calculation queries for branch complete")
 
         if base_branch.name != diff_branch.name:
             current_node_field_specifiers = diff_parser.get_current_node_field_specifiers()
@@ -160,32 +159,15 @@ class DiffCalculator:
             )
             log.info("Diff field-level calculation queries for base complete")
 
-            # Temporary until next change
-            current_node_field_specifier_tuples: list[tuple[str, str]] = []
-            new_node_field_specifier_tuples: list[tuple[str, str]] = []
-            for node_uuid, field_names in current_node_field_specifiers.items():
-                current_node_field_specifier_tuples.extend((node_uuid, field_name) for field_name in field_names)
-            for node_uuid, field_names in new_node_field_specifiers.items():
-                new_node_field_specifier_tuples.extend((node_uuid, field_name) for field_name in field_names)
-
-            base_diff_query = await DiffAllPathsQuery.init(
-                db=self.db,
-                branch=base_branch,
-                base_branch=base_branch,
-                diff_branch_from_time=diff_branch_from_time,
-                diff_from=from_time,
-                diff_to=to_time,
-                current_node_field_specifiers=current_node_field_specifier_tuples,
-                new_node_field_specifiers=new_node_field_specifier_tuples,
+            log.info("Beginning diff property-level calculation queries for base")
+            await self._run_diff_calculation_query(
+                diff_parser=diff_parser,
+                query_class=DiffPropertyPathsQuery,
+                calculation_request=calculation_request,
+                limit=properties_limit,
             )
+            log.info("Diff property-level calculation queries for base complete")
 
-            log.info("Beginning diff calculation query for base")
-            await base_diff_query.execute(db=self.db)
-            log.info("Diff calculation query for base complete")
-            log.info("Reading results of query for base")
-            for query_result in base_diff_query.get_results():
-                diff_parser.read_result(query_result=query_result)
-            log.info("Results of query for branch read")
         log.info("Parsing calculated diff")
         diff_parser.parse(include_unchanged=include_unchanged)
         log.info("Calculated diff parsed")

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/core/diff/combiner.py

@@ -1,7 +1,6 @@
 from copy import deepcopy
 from dataclasses import dataclass, field, replace
 from typing import Iterable
-from uuid import uuid4
 
 from infrahub.core.constants import NULL_VALUE, DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
@@ -342,6 +341,8 @@ class DiffCombiner:
 
     def _copy_node_without_parents(self, node: EnrichedDiffNode) -> EnrichedDiffNode:
         rels_without_parents = {replace(r, nodes=set()) for r in node.relationships}
+        for rel in rels_without_parents:
+            rel.reset_summaries()
         node_without_parents = replace(node, relationships=rels_without_parents)
         return deepcopy(node_without_parents)
 
@@ -351,15 +352,11 @@ class DiffCombiner:
             if node_pair.earlier is None:
                 if node_pair.later is not None:
                     copied = self._copy_node_without_parents(node_pair.later)
-                    for rel in copied.relationships:
-                        rel.reset_summaries()
                     combined_nodes.add(copied)
                 continue
             if node_pair.later is None:
                 if node_pair.earlier is not None:
                     copied = self._copy_node_without_parents(node_pair.earlier)
-                    for rel in copied.relationships:
-                        rel.reset_summaries()
                     combined_nodes.add(copied)
                 continue
             combined_attributes = self._combine_attributes(
@@ -420,14 +417,21 @@ class DiffCombiner:
             filtered_node_pairs = self._filter_nodes_to_keep(earlier_diff=earlier, later_diff=later)
             combined_nodes = self._combine_nodes(node_pairs=filtered_node_pairs)
             self._link_child_nodes(nodes=combined_nodes)
+            if earlier.exists_on_database:
+                diff_uuid = earlier.uuid
+                partner_uuid = earlier.partner_uuid
+            else:
+                diff_uuid = later.uuid
+                partner_uuid = later.partner_uuid
             combined_diffs.append(
                 EnrichedDiffRoot(
-                    uuid=str(uuid4()),
-                    partner_uuid=later.partner_uuid,
+                    uuid=diff_uuid,
+                    partner_uuid=partner_uuid,
                     base_branch_name=later.base_branch_name,
                     diff_branch_name=later.diff_branch_name,
                     from_time=earlier.from_time,
                     to_time=later.to_time,
+                    tracking_id=later.tracking_id,
                     nodes=combined_nodes,
                 )
             )

{infrahub_server-1.1.5 → infrahub_server-1.1.7}/backend/infrahub/core/diff/coordinator.py

@@ -6,6 +6,7 @@ from uuid import uuid4
 
 from infrahub import lock
 from infrahub.core.timestamp import Timestamp
+from infrahub.exceptions import ValidationError
 from infrahub.log import get_logger
 
 from .model.path import (
@@ -29,7 +30,6 @@ if TYPE_CHECKING:
     from .data_check_synchronizer import DiffDataCheckSynchronizer
     from .enricher.aggregated import AggregatedDiffEnricher
     from .enricher.labels import DiffLabelsEnricher
-    from .enricher.summary_counts import DiffSummaryCountsEnricher
     from .repository.repository import DiffRepository
 
 
@@ -42,7 +42,7 @@ class EnrichedDiffRequest:
     diff_branch: Branch
     from_time: Timestamp
     to_time: Timestamp
-    tracking_id: TrackingId | None = field(default=None)
+    tracking_id: TrackingId
     node_field_specifiers: dict[str, set[str]] = field(default_factory=dict)
 
     def __repr__(self) -> str:
@@ -65,7 +65,6 @@ class DiffCoordinator:
         diff_combiner: DiffCombiner,
         conflicts_enricher: ConflictsEnricher,
         labels_enricher: DiffLabelsEnricher,
-        summary_counts_enricher: DiffSummaryCountsEnricher,
         data_check_synchronizer: DiffDataCheckSynchronizer,
         conflict_transferer: DiffConflictTransferer,
     ) -> None:
@@ -75,7 +74,6 @@ class DiffCoordinator:
         self.diff_combiner = diff_combiner
         self.conflicts_enricher = conflicts_enricher
         self.labels_enricher = labels_enricher
-        self.summary_counts_enricher = summary_counts_enricher
         self.data_check_synchronizer = data_check_synchronizer
         self.conflict_transferer = conflict_transferer
         self.lock_registry = lock.registry
@@ -101,6 +99,8 @@ class DiffCoordinator:
             to_timestamp = Timestamp(to_time)
         else:
             to_timestamp = Timestamp()
+        if not name:
+            raise ValidationError("diff with specified time range requires a name")
         await self.create_or_update_arbitrary_timeframe_diff(
             base_branch=base_branch,
             diff_branch=diff_branch,
@@ -115,27 +115,7 @@ class DiffCoordinator:
             lock_name += "__incremental"
         return lock_name
 
-    async def update_branch_diff_and_return(self, base_branch: Branch, diff_branch: Branch) -> EnrichedDiffRoot:
-        enriched_diff = await self.update_branch_diff(base_branch=base_branch, diff_branch=diff_branch)
-        if isinstance(enriched_diff, EnrichedDiffRoot):
-            return enriched_diff
-        return await self._finalize_diff_root_metadata(diff_root_metadata=enriched_diff)
-
-    async def _finalize_diff_root_metadata(self, diff_root_metadata: EnrichedDiffRootMetadata) -> EnrichedDiffRoot:
-        # if this is EnrichedDiffMetadata, we need to retrieve the full diff and set its metadata to match
-        full_enriched_diff = await self.diff_repo.get_one(
-            diff_branch_name=diff_root_metadata.diff_branch_name, diff_id=diff_root_metadata.uuid
-        )
-        full_enriched_diff.update_metadata(
-            from_time=diff_root_metadata.from_time,
-            to_time=diff_root_metadata.to_time,
-            tracking_id=diff_root_metadata.tracking_id,
-        )
-        return full_enriched_diff
-
-    async def update_branch_diff(
-        self, base_branch: Branch, diff_branch: Branch
-    ) -> EnrichedDiffRoot | EnrichedDiffRootMetadata:
+    async def update_branch_diff(self, base_branch: Branch, diff_branch: Branch) -> EnrichedDiffRootMetadata:
         log.info(f"Received request to update branch diff for {base_branch.name} - {diff_branch.name}")
         incremental_lock_name = self._get_lock_name(
             base_branch_name=base_branch.name, diff_branch_name=diff_branch.name, is_incremental=True
@@ -169,12 +149,6 @@ class DiffCoordinator:
                 tracking_id=tracking_id,
                 force_branch_refresh=False,
             )
-            if not isinstance(enriched_diffs, EnrichedDiffs):
-                await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
-                return enriched_diffs.diff_branch_diff
-
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Branch diff update complete for {base_branch.name} - {diff_branch.name}")
@@ -186,11 +160,9 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        name: str | None = None,
-    ) -> EnrichedDiffRoot:
-        tracking_id = None
-        if name:
-            tracking_id = NameTrackingId(name=name)
+        name: str,
+    ) -> EnrichedDiffRootMetadata:
+        tracking_id = NameTrackingId(name=name)
         general_lock_name = self._get_lock_name(
             base_branch_name=base_branch.name, diff_branch_name=diff_branch.name, is_incremental=False
         )
@@ -204,13 +176,7 @@ class DiffCoordinator:
                 tracking_id=tracking_id,
                 force_branch_refresh=False,
             )
-            # metadata-only diff, so no nodes to enrich
-            if not isinstance(enriched_diffs, EnrichedDiffs):
-                await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
-                return await self._finalize_diff_root_metadata(diff_root_metadata=enriched_diffs.diff_branch_diff)
 
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Arbitrary diff update complete for {base_branch.name} - {diff_branch.name}")
@@ -252,8 +218,6 @@ class DiffCoordinator:
                     earlier=current_branch_diff, later=enriched_diffs.diff_branch_diff
                 )
 
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Diff recalculation complete for {base_branch.name} - {diff_branch.name}")
@@ -316,7 +280,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: Literal[True] = ...,
     ) -> EnrichedDiffs: ...
 
@@ -327,7 +291,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: Literal[False] = ...,
     ) -> EnrichedDiffs | EnrichedDiffsMetadata: ...
 
@@ -337,7 +301,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: bool = False,
     ) -> EnrichedDiffs | EnrichedDiffsMetadata:
         # start with empty diffs b/c we only care about their metadata for now, hydrate them with data as needed
@@ -346,6 +310,7 @@ class DiffCoordinator:
             diff_branch_names=[diff_branch.name],
             from_time=from_time,
             to_time=to_time,
+            tracking_id=tracking_id,
         )
         aggregated_enriched_diffs = await self._aggregate_enriched_diffs(
             diff_request=EnrichedDiffRequest(
@@ -357,22 +322,23 @@ class DiffCoordinator:
             ),
             partial_enriched_diffs=diff_pairs_metadata if not force_branch_refresh else None,
         )
-        if tracking_id:
-            diff_uuids_to_delete: list[str] = []
-            for diff_pair in diff_pairs_metadata:
-                if (
-                    diff_pair.base_branch_diff.tracking_id == tracking_id
-                    and diff_pair.base_branch_diff.uuid != aggregated_enriched_diffs.base_branch_diff.uuid
-                ):
-                    diff_uuids_to_delete.append(diff_pair.base_branch_diff.uuid)
-                if (
-                    diff_pair.diff_branch_diff.tracking_id == tracking_id
-                    and diff_pair.diff_branch_diff.uuid != aggregated_enriched_diffs.diff_branch_diff.uuid
-                ):
-                    diff_uuids_to_delete.append(diff_pair.diff_branch_diff.uuid)
-
-            if diff_uuids_to_delete:
-                await self.diff_repo.delete_diff_roots(diff_root_uuids=diff_uuids_to_delete)
+        diff_uuids_to_delete: list[str] = []
+        for diff_pair in diff_pairs_metadata:
+            if (
+                diff_pair.base_branch_diff.tracking_id == tracking_id
+                and diff_pair.base_branch_diff.uuid != aggregated_enriched_diffs.base_branch_diff.uuid
+                and diff_pair.base_branch_diff.exists_on_database
+            ):
+                diff_uuids_to_delete.append(diff_pair.base_branch_diff.uuid)
+            if (
+                diff_pair.diff_branch_diff.tracking_id == tracking_id
+                and diff_pair.diff_branch_diff.uuid != aggregated_enriched_diffs.diff_branch_diff.uuid
+                and diff_pair.diff_branch_diff.exists_on_database
+            ):
+                diff_uuids_to_delete.append(diff_pair.diff_branch_diff.uuid)
+
+        if diff_uuids_to_delete:
+            await self.diff_repo.delete_diff_roots(diff_root_uuids=diff_uuids_to_delete)
 
         # this is an EnrichedDiffsMetadata, so there are no nodes to enrich
         if not isinstance(aggregated_enriched_diffs, EnrichedDiffs):
@@ -459,6 +425,7 @@ class DiffCoordinator:
                         diff_branch=diff_request.diff_branch,
                         from_time=current_time,
                         to_time=end_time,
+                        tracking_id=diff_request.tracking_id,
                     )
                 )
                 current_time = end_time
@@ -481,7 +448,6 @@ class DiffCoordinator:
         aggregated_enriched_diffs.update_metadata(
             from_time=diff_request.from_time, to_time=diff_request.to_time, tracking_id=diff_request.tracking_id
         )
-        aggregated_enriched_diffs.set_fresh_uuids()
         return aggregated_enriched_diffs
 
     async def _concatenate_diffs_and_requests(
@@ -498,6 +464,7 @@ class DiffCoordinator:
             meaning multiple diffs (some that may have been freshly calculated) were combined
         """
         previous_diff_pair: EnrichedDiffs | EnrichedDiffsMetadata | None = None
+        updated_node_uuids: set[str] = set()
         for diff_or_request in diff_or_request_list:
             if isinstance(diff_or_request, EnrichedDiffRequest):
                 if previous_diff_pair:
@@ -508,9 +475,12 @@ class DiffCoordinator:
                     log.info(f"Number node field specifiers: {len(node_field_specifiers)}")
                     diff_or_request.node_field_specifiers = node_field_specifiers
                 is_incremental_diff = diff_or_request.from_time != full_diff_request.from_time
-                single_enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata = await self._calculate_enriched_diff(
+                calculated_diff = await self._calculate_enriched_diff(
                     diff_request=diff_or_request, is_incremental_diff=is_incremental_diff
                 )
+                updated_node_uuids |= calculated_diff.base_node_uuids
+                updated_node_uuids |= calculated_diff.branch_node_uuids
+                single_enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata = calculated_diff
 
             elif isinstance(diff_or_request, EnrichedDiffsMetadata):
                 single_enriched_diffs = diff_or_request
@@ -522,13 +492,20 @@ class DiffCoordinator:
                 continue
 
             log.info("Combining diffs...")
-            previous_diff_pair = await self._combine_diffs(earlier=previous_diff_pair, later=single_enriched_diffs)
+            previous_diff_pair = await self._combine_diffs(
+                earlier=previous_diff_pair,
+                later=single_enriched_diffs,
+                node_uuids=updated_node_uuids,
+            )
             log.info("Diffs combined.")
 
         return previous_diff_pair
 
     async def _combine_diffs(
-        self, earlier: EnrichedDiffs | EnrichedDiffsMetadata, later: EnrichedDiffs | EnrichedDiffsMetadata
+        self,
+        earlier: EnrichedDiffs | EnrichedDiffsMetadata,
+        later: EnrichedDiffs | EnrichedDiffsMetadata,
+        node_uuids: set[str],
     ) -> EnrichedDiffs | EnrichedDiffsMetadata:
         log.info(f"Earlier diff to combine: {earlier!r}")
         log.info(f"Later diff to combine: {later!r}")
@@ -545,11 +522,11 @@ class DiffCoordinator:
         # hydrate the diffs to combine, if necessary
         if not isinstance(earlier, EnrichedDiffs):
             log.info("Hydrating earlier diff...")
-            earlier = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=earlier)
+            earlier = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=earlier, node_uuids=node_uuids)
             log.info("Earlier diff hydrated.")
         if not isinstance(later, EnrichedDiffs):
             log.info("Hydrating later diff...")
-            later = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=later)
+            later = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=later, node_uuids=node_uuids)
             log.info("Later diff hydrated.")
 
         return await self.diff_combiner.combine(earlier_diffs=earlier, later_diffs=later)
@@ -570,6 +547,8 @@ class DiffCoordinator:
             previous_node_specifiers=diff_request.node_field_specifiers,
         )
         log.info("Calculation complete. Enriching diff...")
-        enriched_diff_pair = await self.diff_enricher.enrich(calculated_diffs=calculated_diff_pair)
+        enriched_diff_pair = await self.diff_enricher.enrich(
+            calculated_diffs=calculated_diff_pair, tracking_id=diff_request.tracking_id
+        )
         log.info("Enrichment complete")
         return enriched_diff_pair