cognite-toolkit 0.6.39__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py

@@ -1,40 +1,188 @@
-from typing import Any
+from collections.abc import Iterable, Mapping, Set
+from typing import Any, ClassVar, cast
 
-from cognite.client.data_classes import Asset, Event, FileMetadata, Sequence, TimeSeries
-from cognite.client.data_classes._base import CogniteResource
-from cognite.client.data_classes.data_modeling import MappedProperty, NodeApply, NodeId
-from cognite.client.data_classes.data_modeling.instances import NodeOrEdgeData, PropertyValueWrite
+from cognite.client.data_classes import Annotation, Asset, Event, FileMetadata, TimeSeries
+from cognite.client.data_classes.data_modeling import (
+    DirectRelation,
+    DirectRelationReference,
+    EdgeId,
+    MappedProperty,
+    NodeApply,
+    NodeId,
+)
+from cognite.client.data_classes.data_modeling.instances import EdgeApply, NodeOrEdgeData, PropertyValueWrite
 from cognite.client.data_classes.data_modeling.views import ViewProperty
+from cognite.client.utils._identifier import InstanceId
 
-from cognite_toolkit._cdf_tk.client.data_classes.migration import AssetCentricId, ResourceViewMapping
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.migration import (
+    AssetCentricId,
+    ResourceViewMappingApply,
+)
 from cognite_toolkit._cdf_tk.utils.collection import flatten_dict_json_path
 from cognite_toolkit._cdf_tk.utils.dtype_conversion import (
     asset_centric_convert_to_primary_property,
+    convert_to_primary_property,
+)
+from cognite_toolkit._cdf_tk.utils.useful_types import (
+    AssetCentricResourceExtended,
+    AssetCentricTypeExtended,
 )
-from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentric
 
 from .data_model import INSTANCE_SOURCE_VIEW_ID
 from .issues import ConversionIssue, FailedConversion, InvalidPropertyDataType
 
 
+class DirectRelationCache:
+    """Cache for direct relation references to look up target of direct relations.
+
+    This is used when creating direct relations from asset-centric resources to assets, files, and source systems.
+    """
+
+    class TableName:
+        ASSET_ID = "assetId"
+        SOURCE_NAME = "source"
+        FILE_ID = "fileId"
+        ASSET_EXTERNAL_ID = "assetExternalId"
+        FILE_EXTERNAL_ID = "fileExternalId"
+
+    ASSET_ID_PROPERTIES: ClassVar[Set[tuple[str, str]]] = {
+        ("timeseries", "assetId"),
+        ("file", "assetIds"),
+        ("event", "assetIds"),
+        ("sequence", "assetId"),
+        ("annotation", "data.assetRef.id"),
+        ("asset", "parentId"),
+    }
+    SOURCE_NAME_PROPERTIES: ClassVar[Set[tuple[str, str]]] = {
+        ("asset", "source"),
+        ("event", "source"),
+        ("file", "source"),
+    }
+    FILE_ID_PROPERTIES: ClassVar[Set[tuple[str, str]]] = {
+        ("annotation", "data.fileRef.id"),
+        ("annotation", "annotatedResourceId"),
+    }
+    ASSET_EXTERNAL_ID_PROPERTIES: ClassVar[Set[tuple[str, str]]] = {("annotation", "data.assetRef.externalId")}
+    FILE_EXTERNAL_ID_PROPERTIES: ClassVar[Set[tuple[str, str]]] = {("annotation", "data.fileRef.externalId")}
+
+    def __init__(self, client: ToolkitClient) -> None:
+        self._client = client
+        self._cache_map: dict[
+            tuple[str, str] | str, dict[str, DirectRelationReference] | dict[int, DirectRelationReference]
+        ] = {}
+        # Constructing the cache map to be accessed by both table name and property id
+        for table_name, properties in [
+            (self.TableName.ASSET_ID, self.ASSET_ID_PROPERTIES),
+            (self.TableName.SOURCE_NAME, self.SOURCE_NAME_PROPERTIES),
+            (self.TableName.FILE_ID, self.FILE_ID_PROPERTIES),
+            (self.TableName.ASSET_EXTERNAL_ID, self.ASSET_EXTERNAL_ID_PROPERTIES),
+            (self.TableName.FILE_EXTERNAL_ID, self.FILE_EXTERNAL_ID_PROPERTIES),
+        ]:
+            cache: dict[str, DirectRelationReference] | dict[int, DirectRelationReference] = {}
+            self._cache_map[table_name] = cache
+            for key in properties:
+                self._cache_map[key] = cache
+
+    def update(self, resources: Iterable[AssetCentricResourceExtended]) -> None:
+        """Update the cache with direct relation references for the given asset-centric resources.
+
+        This is used to bulk update the cache for a chunk of resources before converting them to data model instances.
+        """
+        asset_ids: set[int] = set()
+        source_ids: set[str] = set()
+        file_ids: set[int] = set()
+        asset_external_ids: set[str] = set()
+        file_external_ids: set[str] = set()
+        for resource in resources:
+            if isinstance(resource, Annotation):
+                if resource.annotated_resource_type == "file" and resource.annotated_resource_id:
+                    file_ids.add(resource.annotated_resource_id)
+                if "assetRef" in resource.data:
+                    asset_ref = resource.data["assetRef"]
+                    if isinstance(asset_id := asset_ref.get("id"), int):
+                        asset_ids.add(asset_id)
+                    if isinstance(asset_external_id := asset_ref.get("externalId"), str):
+                        asset_external_ids.add(asset_external_id)
+                if "fileRef" in resource.data:
+                    file_ref = resource.data["fileRef"]
+                    if isinstance(file_id := file_ref.get("id"), int):
+                        file_ids.add(file_id)
+                    if isinstance(file_external_id := file_ref.get("externalId"), str):
+                        file_external_ids.add(file_external_id)
+            elif isinstance(resource, Asset):
+                if resource.source:
+                    source_ids.add(resource.source)
+                if resource.parent_id is not None:
+                    asset_ids.add(resource.parent_id)
+            elif isinstance(resource, FileMetadata):
+                if resource.source:
+                    source_ids.add(resource.source)
+                if resource.asset_ids:
+                    asset_ids.update(resource.asset_ids)
+            elif isinstance(resource, Event):
+                if resource.source:
+                    source_ids.add(resource.source)
+                if resource.asset_ids:
+                    asset_ids.update(resource.asset_ids)
+            elif isinstance(resource, TimeSeries):
+                if resource.asset_id is not None:
+                    asset_ids.add(resource.asset_id)
+        if asset_ids:
+            self._update_cache(self._client.migration.lookup.assets(id=list(asset_ids)), self.TableName.ASSET_ID)
+        if source_ids:
+            # SourceSystems are not cached in the client, so we have to handle the caching ourselves.
+            cache = cast(dict[str, DirectRelationReference], self._cache_map[self.TableName.SOURCE_NAME])
+            missing = set(source_ids) - set(cache.keys())
+            if missing:
+                source_systems = self._client.migration.created_source_system.retrieve(list(missing))
+                for source_system in source_systems:
+                    cache[source_system.source] = source_system.as_direct_relation_reference()
+        if file_ids:
+            self._update_cache(self._client.migration.lookup.files(id=list(file_ids)), self.TableName.FILE_ID)
+        if asset_external_ids:
+            self._update_cache(
+                self._client.migration.lookup.assets(external_id=list(asset_external_ids)),
+                self.TableName.ASSET_EXTERNAL_ID,
+            )
+        if file_external_ids:
+            self._update_cache(
+                self._client.migration.lookup.files(external_id=list(file_external_ids)),
+                self.TableName.FILE_EXTERNAL_ID,
+            )
+
+    def _update_cache(self, instance_id_by_id: dict[int, NodeId] | dict[str, NodeId], table_name: str) -> None:
+        cache = self._cache_map[table_name]
+        for identifier, instance_id in instance_id_by_id.items():
+            cache[identifier] = DirectRelationReference(space=instance_id.space, external_id=instance_id.external_id)  # type: ignore[index]
+
+    def get_cache(
+        self, resource_type: AssetCentricTypeExtended, property_id: str
+    ) -> Mapping[str | int, DirectRelationReference] | None:
+        """Get the cache for the given resource type and property ID."""
+        return self._cache_map.get((resource_type, property_id))  # type: ignore[return-value]
+
+
 def asset_centric_to_dm(
-    resource: CogniteResource,
-    instance_id: NodeId,
-    view_source: ResourceViewMapping,
+    resource: AssetCentricResourceExtended,
+    instance_id: InstanceId,
+    view_source: ResourceViewMappingApply,
     view_properties: dict[str, ViewProperty],
-) -> tuple[NodeApply, ConversionIssue]:
+    direct_relation_cache: DirectRelationCache,
+) -> tuple[NodeApply | EdgeApply | None, ConversionIssue]:
     """Convert an asset-centric resource to a data model instance.
 
     Args:
         resource (CogniteResource): The asset-centric resource to convert.
-        instance_id (NodeId): The ID of the instance to create or update.
-        view_source (ResourceViewMapping): The view source defining how to map the resource to the data model.
+        instance_id (NodeId | EdgeApply): The ID of the instance to create or update.
+        view_source (ResourceViewMappingApply): The view source defining how to map the resource to the data model.
         view_properties (dict[str, ViewProperty]): The defined properties referenced in the view source mapping.
+        direct_relation_cache (DirectRelationCache): Cache for direct relation references.
 
     Returns:
-        tuple[NodeApply, ConversionIssue]: A tuple containing the converted NodeApply and any ConversionIssue encountered.
+        tuple[NodeApply | EdgeApply, ConversionIssue]: A tuple containing the converted NodeApply and any ConversionIssue encountered.
     """
-    resource_type = _lookup_resource_type(type(resource))
+    resource_type = _lookup_resource_type(resource)
     dumped = resource.dump()
     try:
         id_ = dumped.pop("id")
@@ -53,47 +201,68 @@ def asset_centric_to_dm(
         view_source.property_mapping,
         resource_type,
         issue=issue,
+        direct_relation_cache=direct_relation_cache,
     )
     sources: list[NodeOrEdgeData] = []
     if properties:
         sources.append(NodeOrEdgeData(source=view_source.view_id, properties=properties))
-    instance_source_properties = {
-        "resourceType": resource_type,
-        "id": id_,
-        "dataSetId": data_set_id,
-        "classicExternalId": external_id,
-    }
-    sources.append(NodeOrEdgeData(source=INSTANCE_SOURCE_VIEW_ID, properties=instance_source_properties))
 
-    node = NodeApply(
-        space=instance_id.space,
-        external_id=instance_id.external_id,
-        sources=sources,
-    )
+    if resource_type != "annotation":
+        instance_source_properties = {
+            "resourceType": resource_type,
+            "id": id_,
+            "dataSetId": data_set_id,
+            "classicExternalId": external_id,
+        }
+        sources.append(NodeOrEdgeData(source=INSTANCE_SOURCE_VIEW_ID, properties=instance_source_properties))
 
-    return node, issue
+    instance: NodeApply | EdgeApply
+    if isinstance(instance_id, EdgeId):
+        edge_properties = create_edge_properties(
+            dumped, view_source.property_mapping, resource_type, issue, direct_relation_cache, instance_id.space
+        )
+        if any(key not in edge_properties for key in ("start_node", "end_node", "type")):
+            # Failed conversion of edge properties
+            return None, issue
+        instance = EdgeApply(
+            space=instance_id.space,
+            external_id=instance_id.external_id,
+            sources=sources,
+            **edge_properties,  # type: ignore[arg-type]
+        )
+    elif isinstance(instance_id, NodeId):
+        instance = NodeApply(space=instance_id.space, external_id=instance_id.external_id, sources=sources)
+    else:
+        raise RuntimeError(f"Unexpected instance_id type {type(instance_id)}")
 
+    return instance, issue
 
-def _lookup_resource_type(resource_type: type[CogniteResource]) -> AssetCentric:
-    resource_type_map: dict[type[CogniteResource], AssetCentric] = {
-        Asset: "asset",
-        FileMetadata: "file",
-        Event: "event",
-        TimeSeries: "timeseries",
-        Sequence: "sequence",
-    }
-    try:
-        return resource_type_map[resource_type]
-    except KeyError as e:
-        raise ValueError(f"Unsupported resource type: {resource_type}") from e
+
+def _lookup_resource_type(resource_type: AssetCentricResourceExtended) -> AssetCentricTypeExtended:
+    if isinstance(resource_type, Asset):
+        return "asset"
+    elif isinstance(resource_type, FileMetadata):
+        return "file"
+    elif isinstance(resource_type, Event):
+        return "event"
+    elif isinstance(resource_type, TimeSeries):
+        return "timeseries"
+    elif isinstance(resource_type, Annotation):
+        if resource_type.annotated_resource_type == "file" and resource_type.annotation_type in (
+            "diagrams.AssetLink",
+            "diagrams.FileLink",
+        ):
+            return "annotation"
+    raise ValueError(f"Unsupported resource type: {resource_type}")
 
 
 def create_properties(
     dumped: dict[str, Any],
     view_properties: dict[str, ViewProperty],
     property_mapping: dict[str, str],
-    resource_type: AssetCentric,
+    resource_type: AssetCentricTypeExtended,
     issue: ConversionIssue,
+    direct_relation_cache: DirectRelationCache,
 ) -> dict[str, PropertyValueWrite]:
     """
     Create properties for a data model instance from an asset-centric resource.
@@ -104,6 +273,7 @@ def create_properties(
         property_mapping:  Mapping from asset-centric property IDs to data model property IDs.
         resource_type: The type of the asset-centric resource (e.g., "asset", "timeseries").
         issue: ConversionIssue object to log any issues encountered during conversion.
+        direct_relation_cache: Cache for direct relation references to look up target of direct relations.
 
     Returns:
         Dict of property IDs to PropertyValueWrite objects.
@@ -133,6 +303,7 @@ def create_properties(
                 dm_prop.nullable,
                 destination_container_property=(dm_prop.container, dm_prop.container_property_identifier),
                 source_property=(resource_type, prop_json_path),
+                direct_relation_lookup=direct_relation_cache.get_cache(resource_type, prop_json_path),
             )
         except (ValueError, TypeError, NotImplementedError) as e:
             issue.failed_conversions.append(
@@ -145,5 +316,58 @@ def create_properties(
         (set(flatten_dump.keys()) - set(property_mapping.keys())) | ignored_asset_centric_properties
     )
     issue.missing_asset_centric_properties = sorted(set(property_mapping.keys()) - set(flatten_dump.keys()))
-    issue.missing_instance_properties = sorted(set(property_mapping.values()) - set(view_properties.keys()))
+    # Node and edge properties are handled separately
+    issue.missing_instance_properties = sorted(
+        {
+            prop_id
+            for prop_id in property_mapping.values()
+            if not (prop_id.startswith("edge.") or prop_id.startswith("node."))
+        }
+        - set(view_properties.keys())
+    )
     return properties
+
+
+def create_edge_properties(
+    dumped: dict[str, Any],
+    property_mapping: dict[str, str],
+    resource_type: AssetCentricTypeExtended,
+    issue: ConversionIssue,
+    direct_relation_cache: DirectRelationCache,
+    default_instance_space: str,
+) -> dict[str, DirectRelationReference]:
+    flatten_dump = flatten_dict_json_path(dumped)
+    edge_properties: dict[str, DirectRelationReference] = {}
+    for prop_json_path, prop_id in property_mapping.items():
+        if not prop_id.startswith("edge."):
+            continue
+        if prop_json_path not in flatten_dump:
+            continue
+        edge_prop_id = prop_id.removeprefix("edge.")
+        if edge_prop_id in ("startNode", "endNode", "type"):
+            # DirectRelation lookup.
+            try:
+                value = convert_to_primary_property(
+                    flatten_dump[prop_json_path],
+                    DirectRelation(),
+                    False,
+                    direct_relation_lookup=direct_relation_cache.get_cache(resource_type, prop_json_path),
+                )
+            except (ValueError, TypeError, NotImplementedError) as e:
+                issue.failed_conversions.append(
+                    FailedConversion(property_id=prop_json_path, value=flatten_dump[prop_json_path], error=str(e))
+                )
+                continue
+        elif edge_prop_id.endswith(".externalId"):
+            # Just an external ID string.
+            edge_prop_id = edge_prop_id.removesuffix(".externalId")
+            value = DirectRelationReference(default_instance_space, str(flatten_dump[prop_json_path]))
+        else:
+            issue.invalid_instance_property_types.append(
+                InvalidPropertyDataType(property_id=prop_id, expected_type="EdgeProperty")
+            )
+            continue
+        # We know that value is DirectRelationReference here
+        edge_properties[edge_prop_id.replace("Node", "_node")] = value  # type: ignore[assignment]
+
+    return edge_properties

cognite_toolkit/_cdf_tk/commands/_migrate/creators.py

@@ -0,0 +1,232 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Generic
+
+from cognite.client.data_classes import DataSetList, filters
+from cognite.client.data_classes._base import T_CogniteResourceList
+from cognite.client.data_classes.aggregations import UniqueResult
+from cognite.client.data_classes.assets import AssetProperty
+from cognite.client.data_classes.data_modeling import (
+    NodeApply,
+    NodeApplyList,
+    NodeOrEdgeData,
+    SpaceApply,
+    SpaceApplyList,
+    ViewId,
+)
+from cognite.client.data_classes.documents import SourceFileProperty
+from cognite.client.data_classes.events import EventProperty
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import APMConfig, APMConfigList
+from cognite_toolkit._cdf_tk.cruds import NodeCRUD, ResourceCRUD, SpaceCRUD
+from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError, ToolkitRequiredValueError
+from cognite_toolkit._cdf_tk.utils import humanize_collection
+
+from .data_model import CREATED_SOURCE_SYSTEM_VIEW_ID, SPACE, SPACE_SOURCE_VIEW_ID
+
+
+@dataclass
+class ResourceConfig:
+    filestem: str
+    data: dict[str, Any]
+
+
+class MigrationCreator(ABC, Generic[T_CogniteResourceList]):
+    """Base class for migration resources configurations that are created resources."""
+
+    CRUD: type[ResourceCRUD]
+    DISPLAY_NAME: str
+    HAS_LINEAGE: bool = True
+
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+
+    @abstractmethod
+    def create_resources(self) -> T_CogniteResourceList:
+        raise NotImplementedError("Subclasses should implement this method")
+
+    @abstractmethod
+    def resource_configs(self, resources: T_CogniteResourceList) -> list[ResourceConfig]:
+        raise NotImplementedError("Subclasses should implement this method")
+
+    def store_lineage(self, resources: T_CogniteResourceList) -> int:
+        """Store lineage information for the created resources.
+
+        Args:
+            resources: The list of created resources.
+        """
+        raise NotImplementedError("Subclasses should implement this method")
+
+
+class InstanceSpaceCreator(MigrationCreator[SpaceApplyList]):
+    """Creates instance spaces for migration."""
+
+    CRUD = SpaceCRUD
+    DISPLAY_NAME = "Instance Space"
+    HAS_LINEAGE = True
+
+    def __init__(
+        self, client: ToolkitClient, datasets: DataSetList | None = None, data_set_external_ids: list[str] | None = None
+    ) -> None:
+        super().__init__(client)
+        if sum([datasets is not None, data_set_external_ids is not None]) != 1:
+            raise ValueError("Exactly one of datasets or data_set_external_ids must be provided.")
+        self.data_set_external_ids = data_set_external_ids
+        self.datasets = datasets or DataSetList([])
+
+    def create_resources(self) -> SpaceApplyList:
+        if self.data_set_external_ids is not None:
+            self.datasets = self.client.data_sets.retrieve_multiple(external_ids=self.data_set_external_ids)
+
+        if missing_external_ids := [ds.id for ds in self.datasets if ds.external_id is None]:
+            raise ToolkitRequiredValueError(
+                f"Cannot create instance spaces for datasets with missing external IDs: {humanize_collection(missing_external_ids)}"
+            )
+
+        return SpaceApplyList(
+            [
+                SpaceApply(
+                    # This is checked above
+                    space=dataset.external_id,  # type: ignore[arg-type]
+                    name=dataset.name,
+                    description=dataset.description,
+                )
+                for dataset in self.datasets
+            ]
+        )
+
+    def resource_configs(self, resources: SpaceApplyList) -> list[ResourceConfig]:
+        return [ResourceConfig(filestem=space.space, data=space.dump()) for space in resources]
+
+    def store_lineage(self, resources: SpaceApplyList) -> int:
+        data_set_by_external_id = {ds.external_id: ds for ds in self.datasets}
+        nodes = NodeApplyList(
+            [
+                NodeApply(
+                    space=SPACE.space,
+                    external_id=space.space,
+                    sources=[
+                        NodeOrEdgeData(
+                            source=SPACE_SOURCE_VIEW_ID,
+                            properties={
+                                "instanceSpace": space.space,
+                                "dataSetId": data_set_by_external_id[space.space].id,
+                                "dataSetExternalId": data_set_by_external_id[space.space].external_id,
+                            },
+                        )
+                    ],
+                )
+                for space in resources
+            ]
+        )
+        res = self.client.data_modeling.instances.apply(nodes)
+        return len(res.nodes)
+
+
+class SourceSystemCreator(MigrationCreator[NodeApplyList]):
+    CRUD = NodeCRUD
+    DISPLAY_NAME = "Source System"
+    COGNITE_SOURCE_SYSTEM_VIEW_ID = ViewId("cdf_cdm", "CogniteSourceSystem", "v1")
+
+    def __init__(
+        self,
+        client: ToolkitClient,
+        instance_space: str,
+        data_set_external_id: str | None = None,
+        hierarchy: str | None = None,
+    ) -> None:
+        super().__init__(client)
+        if sum([data_set_external_id is not None, hierarchy is not None]) != 1:
+            raise ValueError("Exactly one of data_set_external_id or hierarchy must be provided.")
+        self._instance_space = instance_space
+        self.data_set_external_id = data_set_external_id
+        self.hierarchy = hierarchy
+
+    def create_resources(self) -> NodeApplyList:
+        seen: set[str] = set()
+        nodes = NodeApplyList([])
+        for source in self._lookup_sources():
+            source_str = source.value
+            if not isinstance(source_str, str) or source_str in seen:
+                continue
+            seen.add(source_str)
+            nodes.append(
+                NodeApply(
+                    space=self._instance_space,
+                    external_id=source_str,
+                    sources=[
+                        NodeOrEdgeData(source=self.COGNITE_SOURCE_SYSTEM_VIEW_ID, properties={"name": source_str}),
+                        NodeOrEdgeData(source=CREATED_SOURCE_SYSTEM_VIEW_ID, properties={"source": source_str}),
+                    ],
+                )
+            )
+        return nodes
+
+    def resource_configs(self, resources: NodeApplyList) -> list[ResourceConfig]:
+        output: list[ResourceConfig] = []
+        for node in resources:
+            copy = NodeApply(
+                space=node.space,
+                external_id=node.external_id,
+                # We remove the lineage source as this is not expected to be part of the governed
+                # SourceSystem.
+                sources=[s for s in node.sources if s.source != CREATED_SOURCE_SYSTEM_VIEW_ID],
+            )
+            output.append(ResourceConfig(filestem=node.external_id, data=copy.dump()))
+        return output
+
+    def _lookup_sources(self) -> Iterable[UniqueResult]:
+        yield from self.client.assets.aggregate_unique_values(AssetProperty.source, filter=self._simple_filter)
+        yield from self.client.events.aggregate_unique_values(property=EventProperty.source, filter=self._simple_filter)
+        yield from self.client.documents.aggregate_unique_values(
+            SourceFileProperty.source, filter=self._advanced_filter, limit=1000
+        )
+
+    @cached_property
+    def _simple_filter(self) -> dict[str, Any] | None:
+        if self.data_set_external_id is not None:
+            return {"dataSetIds": [{"externalId": self.data_set_external_id}]}
+        if self.hierarchy is not None:
+            return {"assetSubtreeIds": [{"externalId": self.hierarchy}]}
+        return None
+
+    @cached_property
+    def _advanced_filter(self) -> filters.Filter:
+        if self.data_set_external_id is not None:
+            data_set_id = self.client.lookup.data_sets.id(self.data_set_external_id)
+            if data_set_id is None:
+                raise ToolkitMissingResourceError(f"Data set with external ID '{self.data_set_external_id}' not found.")
+            return filters.Equals(SourceFileProperty.data_set_id, data_set_id)
+        if self.hierarchy is not None:
+            return filters.InAssetSubtree(SourceFileProperty.asset_external_ids, [self.hierarchy])
+        else:
+            raise ValueError("This should not happen.")
+
+    def store_lineage(self, resources: NodeApplyList) -> int:
+        # We already store lineage when creating the resources.
+        return len(resources)
+
+
+class InfieldV2ConfigCreator(MigrationCreator[NodeApplyList]):
+    CRUD = NodeCRUD
+    DISPLAY_NAME = "Infield V2 Configuration"
+    HAS_LINEAGE = False
+
+    def create_resources(self) -> NodeApplyList:
+        apm_config_nodes = self.client.data_modeling.instances.list(instance_type="node", sources=APMConfig.view_id)
+        apm_config = APMConfigList.from_nodes(apm_config_nodes)
+
+        new_config_nodes = NodeApplyList([])
+        for config in apm_config:
+            new_config = self._create_infield_v2_config(config)
+            new_config_nodes.append(new_config)
+        return new_config_nodes
+
+    def resource_configs(self, resources: NodeApplyList) -> list[ResourceConfig]:
+        return [ResourceConfig(filestem=node.external_id, data=node.dump()) for node in resources]
+
+    def _create_infield_v2_config(self, config: APMConfig) -> NodeApply:
+        raise NotImplementedError("To be implemented")