infrahub-server 1.4.0b0__py3-none-any.whl → 1.4.0b1__py3-none-any.whl

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 35
+GRAPH_VERSION = 36

infrahub/core/migrations/graph/__init__.py

@@ -37,6 +37,7 @@ from .m032_cleanup_orphaned_branch_relationships import Migration032
 from .m033_deduplicate_relationship_vertices import Migration033
 from .m034_find_orphaned_schema_fields import Migration034
 from .m035_drop_attr_value_index import Migration035
+from .m036_index_attr_vals import Migration036
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -79,6 +80,7 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration033,
     Migration034,
     Migration035,
+    Migration036,
 ]
 
 

infrahub/core/migrations/graph/m036_index_attr_vals.py

@@ -0,0 +1,577 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from rich.console import Console
+
+from infrahub.constants.database import IndexType
+from infrahub.core.attribute import MAX_STRING_LENGTH
+from infrahub.core.migrations.shared import MigrationResult
+from infrahub.core.query import Query, QueryType
+from infrahub.core.timestamp import Timestamp
+from infrahub.database.index import IndexItem
+from infrahub.database.neo4j import IndexManagerNeo4j
+from infrahub.log import get_logger
+
+from ..shared import ArbitraryMigration
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+AV_INDEXED_INDEX = IndexItem(
+    name="attr_value_indexed", label="AttributeValueIndexed", properties=["value"], type=IndexType.RANGE
+)
+
+
+@dataclass
+class SchemaAttributeTimeframe:
+    kind: str
+    attr_name: str
+    branch: str
+    branch_level: int
+    branched_from: str
+    from_time: str
+    is_default_branch: bool
+    is_large_type: bool
+
+
+class GetLargeAttributeTypesQuery(Query):
+    """For every active attribute on every branch, return a SchemaAttributeTimeframe object"""
+
+    name = "get_large_attribute_types_query"
+    type = QueryType.READ
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (branch:Branch)
+// --------------
+// find all SchemaAttributes with a LARGE_ATTRIBUTE_TYPE kind for each branch
+// --------------
+MATCH (schema_attr:SchemaAttribute)-[r1:HAS_ATTRIBUTE]->(attr_kind:Attribute {name: "kind"})-[r2:HAS_VALUE]->(attr_kind_value)
+WHERE r1.status = "active" and r1.to IS NULL AND r2.status = "active" and r2.to IS NULL
+WITH DISTINCT branch, schema_attr, attr_kind
+CALL (schema_attr, attr_kind, branch) {
+    MATCH (schema_attr)-[has_attr:HAS_ATTRIBUTE]->(attr_kind)-[has_value:HAS_VALUE]->(attr_kind_value)
+    WHERE has_attr.status = "active"
+    AND has_value.status = "active"
+    AND has_attr.to IS NULL
+    AND has_value.to IS NULL
+    AND (
+        has_attr.branch = branch.name
+        OR (has_attr.branch_level < branch.hierarchy_level AND has_attr.from <= branch.branched_from)
+    )
+    AND (
+        has_value.branch = branch.name
+        OR (has_value.branch_level < branch.hierarchy_level AND has_value.from <= branch.branched_from)
+    )
+    WITH has_value.from AS from_time, attr_kind_value.value AS attr_type
+    ORDER BY has_value.branch_level DESC, has_value.from DESC
+    LIMIT 1
+    WITH from_time, attr_type
+    RETURN from_time, attr_type IN ["JSON", "List", "TextArea"] AS is_large_type
+}
+CALL (schema_attr, branch) {
+    // --------------
+    // get the attribute name
+    // --------------
+    MATCH (schema_attr)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(name_value)
+    WHERE r1.status = "active"
+    AND r1.to IS NULL
+    AND (
+        r1.branch = branch.name
+        OR (r1.branch_level < branch.hierarchy_level AND r1.from <= branch.branched_from)
+    )
+    AND r2.status = "active"
+    AND r2.to IS NULL
+    AND (
+        r2.branch = branch.name
+        OR (r2.branch_level < branch.hierarchy_level AND r2.from <= branch.branched_from)
+    )
+    WITH name_value.value AS attr_name
+    ORDER BY r2.branch_level DESC, r1.branch_level DESC, r2.from DESC, r1.from DESC
+    LIMIT 1
+
+    // --------------
+    // get the the schema node/generic
+    // --------------
+    MATCH (schema_attr)-[r1:IS_RELATED]-(:Relationship {name: "schema__node__attributes"})-[r2:IS_RELATED]-(schema_node:SchemaNode|SchemaGeneric)
+    WHERE r1.status = "active"
+    AND r1.to IS NULL
+    AND (
+        r1.branch = branch.name
+        OR (r1.branch_level < branch.hierarchy_level AND r1.from <= branch.branched_from)
+    )
+    AND r2.status = "active"
+    AND r2.to IS NULL
+    AND (
+        r2.branch = branch.name
+        OR (r2.branch_level < branch.hierarchy_level AND r2.from <= branch.branched_from)
+    )
+    WITH attr_name, schema_node
+    ORDER BY r2.branch_level DESC, r1.branch_level DESC, r2.from DESC, r1.from DESC
+    LIMIT 1
+
+    // --------------
+    // find the namespace for this SchemaNode/SchemaGeneric
+    // --------------
+    MATCH (schema_node)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "namespace"})-[r2:HAS_VALUE]->(kind_namespace_value)
+    WHERE r1.status = "active"
+    AND r1.to IS NULL
+    AND (
+        r1.branch = branch.name
+        OR (r1.branch_level < branch.hierarchy_level AND r1.from <= branch.branched_from)
+    )
+    AND r2.status = "active"
+    AND r2.to IS NULL
+    AND (
+        r2.branch = branch.name
+        OR (r2.branch_level < branch.hierarchy_level AND r2.from <= branch.branched_from)
+    )
+    WITH attr_name, schema_node, kind_namespace_value.value AS kind_namespace
+    ORDER BY r2.branch_level DESC, r1.branch_level DESC, r2.from DESC, r1.from DESC
+    LIMIT 1
+
+    // --------------
+    // find the name for this SchemaNode/SchemaGeneric
+    // --------------
+    MATCH (schema_node)-[r1:HAS_ATTRIBUTE]->(:Attribute {name: "name"})-[r2:HAS_VALUE]->(kind_name_value)
+    WHERE r1.status = "active"
+    AND r1.to IS NULL
+    AND (
+        r1.branch = branch.name
+        OR (r1.branch_level < branch.hierarchy_level AND r1.from <= branch.branched_from)
+    )
+    AND r2.status = "active"
+    AND r2.to IS NULL
+    AND (
+        r2.branch = branch.name
+        OR (r2.branch_level < branch.hierarchy_level AND r2.from <= branch.branched_from)
+    )
+    WITH attr_name, kind_namespace, kind_name_value.value AS kind_name
+    ORDER BY r2.branch_level DESC, r1.branch_level DESC, r2.from DESC, r1.from DESC
+    LIMIT 1
+    RETURN attr_name, kind_namespace, kind_name
+}
+RETURN
+    kind_namespace,
+    kind_name,
+    attr_name,
+    branch.name AS branch,
+    branch.hierarchy_level AS branch_level,
+    branch.branched_from AS branched_from,
+    branch.is_default AS is_default_branch,
+    from_time,
+    is_large_type
+"""
+        self.add_to_query(query)
+        self.return_labels = [
+            "kind_namespace",
+            "kind_name",
+            "attr_name",
+            "branch",
+            "branch_level",
+            "branched_from",
+            "is_default_branch",
+            "from_time",
+            "is_large_type",
+        ]
+
+    def get_large_attribute_type_timeframes(self) -> list[SchemaAttributeTimeframe]:
+        schema_attribute_timeframes: list[SchemaAttributeTimeframe] = []
+        for result in self.get_results():
+            kind_namespace = result.get_as_type("kind_namespace", return_type=str)
+            kind_name = result.get_as_type("kind_name", return_type=str)
+            attr_name = result.get_as_type("attr_name", return_type=str)
+            branch = result.get_as_type("branch", return_type=str)
+            branch_level = result.get_as_type("branch_level", return_type=int)
+            branched_from = result.get_as_type("branched_from", return_type=str)
+            is_default_branch = result.get_as_type("is_default_branch", return_type=bool)
+            is_large_type = result.get_as_type("is_large_type", return_type=bool)
+            from_time = result.get_as_type("from_time", return_type=str)
+            kind = f"{kind_namespace}{kind_name}"
+            schema_attribute_timeframes.append(
+                SchemaAttributeTimeframe(
+                    kind=kind,
+                    attr_name=attr_name,
+                    branch=branch,
+                    branch_level=branch_level,
+                    branched_from=branched_from,
+                    from_time=from_time,
+                    is_default_branch=is_default_branch,
+                    is_large_type=is_large_type,
+                )
+            )
+        return schema_attribute_timeframes
+
+
+class DeIndexLargeAttributeValuesQuery(Query):
+    name = "de_index_large_attribute_values_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(self, max_value_size: int, **kwargs: Any) -> None:
+        self.max_value_size = max_value_size
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["max_value_size"] = self.max_value_size
+        query = """
+MATCH (av:AttributeValueIndexed)
+WHERE size(toString(av.value)) > $max_value_size
+REMOVE av:AttributeValueIndexed
+        """
+        self.add_to_query(query)
+
+
+class CreateNonIndexedAttributeValueQuery(Query):
+    name = "create_non_indexed_attribute_value_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        schema_attribute_timeframe: SchemaAttributeTimeframe,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.schema_attribute_timeframe = schema_attribute_timeframe
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params.update(
+            {
+                "attribute_name": self.schema_attribute_timeframe.attr_name,
+                "branch": self.schema_attribute_timeframe.branch,
+                "branch_level": self.schema_attribute_timeframe.branch_level,
+                "branched_from": self.schema_attribute_timeframe.branched_from,
+                "from_time": self.schema_attribute_timeframe.from_time,
+            }
+        )
+        query = """
+MATCH (node:Node:%(schema_kind)s)
+CALL (node) {
+    MATCH (node)-[has_attr_e:HAS_ATTRIBUTE]->(attr:Attribute)
+    WHERE attr.name = $attribute_name
+    AND (
+        has_attr_e.branch = $branch
+        OR (has_attr_e.branch_level < $branch_level AND has_attr_e.from <= $branched_from)
+    )
+    AND has_attr_e.status = "active"
+    AND has_attr_e.to IS NULL
+    WITH attr
+    ORDER BY has_attr_e.branch_level DESC, has_attr_e.from DESC
+    LIMIT 1
+
+    // --------------
+    // identify the active HAS_VALUE edges that we need to consider
+    // --------------
+    MATCH (attr)-[has_val_e:HAS_VALUE]->(av)
+    WHERE (
+        has_val_e.branch = $branch
+        OR (has_val_e.branch_level < $branch_level AND has_val_e.from <= $branched_from)
+    )
+    AND has_val_e.status = "active"
+    AND has_val_e.to IS NULL
+    RETURN attr, has_val_e, av
+    ORDER BY has_val_e.branch_level DESC, has_val_e.from DESC
+    LIMIT 1
+}
+// --------------------
+// determine the timestamp to de-index the AttributeValue
+// --------------------
+WITH attr, has_val_e, av,
+CASE
+    WHEN $from_time <= has_val_e.from THEN has_val_e.from
+    ELSE $from_time
+END AS non_indexed_from
+
+// --------------------
+// create the new edge to the AttributeValueNonIndexed vertex, if necessary
+// --------------------
+WITH attr, has_val_e, av, non_indexed_from
+CALL (attr, has_val_e, av, non_indexed_from) {
+    WITH has_val_e
+    WHERE NOT "AttributeValueNonIndexed" IN labels(av)
+
+    MERGE (av_no_index:AttributeValueNonIndexed {value: av.value, is_default: av.is_default})
+    LIMIT 1
+
+    CREATE (attr)-[add_no_index_on_branch:HAS_VALUE]->(av_no_index)
+    SET add_no_index_on_branch = properties(has_val_e)
+    SET
+        add_no_index_on_branch.branch = $branch,
+        add_no_index_on_branch.branch_level = $branch_level,
+        add_no_index_on_branch.from = non_indexed_from,
+        add_no_index_on_branch.status = "active",
+        add_no_index_on_branch.to = NULL
+
+    // --------------------
+    // delete existing active edge if it is on this branch and we created a new edge
+    // --------------------
+    WITH has_val_e
+    WHERE has_val_e.branch = $branch
+    DELETE has_val_e
+
+}
+        """ % {"schema_kind": self.schema_attribute_timeframe.kind}
+        self.add_to_query(query)
+
+
+class RevertNonIndexOnBranchQuery(Query):
+    name = "revert_non_index_on_branch_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        schema_attribute_timeframe: SchemaAttributeTimeframe,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.schema_attribute_timeframe = schema_attribute_timeframe
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params.update(
+            {
+                "attribute_name": self.schema_attribute_timeframe.attr_name,
+                "branch": self.schema_attribute_timeframe.branch,
+                "branch_level": self.schema_attribute_timeframe.branch_level,
+                "branched_from": self.schema_attribute_timeframe.branched_from,
+                "from_time": self.schema_attribute_timeframe.from_time,
+            }
+        )
+        query = """
+MATCH (node:Node:%(schema_kind)s)
+CALL (node) {
+    MATCH (node)-[has_attr_e:HAS_ATTRIBUTE]->(attr:Attribute)
+    WHERE attr.name = $attribute_name
+    AND (
+        has_attr_e.branch = $branch
+        OR (has_attr_e.branch_level < $branch_level AND has_attr_e.from <= $branched_from)
+    )
+    AND has_attr_e.status = "active"
+    AND has_attr_e.to IS NULL
+    WITH attr
+    ORDER BY has_attr_e.branch_level DESC, has_attr_e.from DESC
+    LIMIT 1
+
+    // --------------
+    // identify the active HAS_VALUE edges that we need to consider
+    // --------------
+    MATCH (attr)-[has_val_e:HAS_VALUE]->(av)
+    WHERE (
+        has_val_e.branch = $branch
+        OR (has_val_e.branch_level < $branch_level AND has_val_e.from <= $branched_from)
+    )
+    AND has_val_e.status = "active"
+    AND has_val_e.to IS NULL
+    RETURN attr, has_val_e, av
+    ORDER BY has_val_e.branch_level DESC, has_val_e.from DESC
+    LIMIT 1
+}
+
+// --------------------
+// determine the timestamp to index the AttributeValue
+// --------------------
+WITH attr, has_val_e, av,
+CASE
+    WHEN $from_time <= has_val_e.from THEN has_val_e.from
+    ELSE $from_time
+END AS indexed_from
+
+// --------------------
+// create the new edge to the AttributeValue vertex
+// --------------------
+WITH attr, has_val_e, av, indexed_from
+CALL (attr, has_val_e, av, indexed_from) {
+    WITH has_val_e
+    WHERE NOT "AttributeValue" IN labels(av)
+
+    MERGE (av_index:AttributeValue {value: av.value, is_default: av.is_default})
+    LIMIT 1
+
+    CREATE (attr)-[add_index_on_branch:HAS_VALUE]->(av_index)
+    SET add_index_on_branch = properties(has_val_e)
+    SET
+        add_index_on_branch.branch = $branch,
+        add_index_on_branch.branch_level = $branch_level,
+        add_index_on_branch.from = indexed_from,
+        add_index_on_branch.status = "active",
+        add_index_on_branch.to = NULL
+
+    // --------------------
+    // delete existing active edge if it is on this branch and we created a new edge
+    // --------------------
+    WITH has_val_e
+    WHERE has_val_e.branch = $branch AND add_index_on_branch IS NOT NULL
+    DELETE has_val_e
+}
+        """ % {"schema_kind": self.schema_attribute_timeframe.kind}
+        self.add_to_query(query)
+
+
+class SetAttributeValueIndexedQuery(Query):
+    name = "set_attribute_value_indexed_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (av:AttributeValue)
+SET av:AttributeValueIndexed
+        """
+        self.add_to_query(query)
+
+
+class FinalizeAttributeValueNonIndexedQuery(Query):
+    name = "finalize_attribute_value_non_indexed_query"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        query = """
+MATCH (av_no_index:AttributeValueNonIndexed)
+SET av_no_index:AttributeValue
+REMOVE av_no_index:AttributeValueNonIndexed
+        """
+        self.add_to_query(query)
+
+
+class Migration036(ArbitraryMigration):
+    """
+    Update AttributeValue vertices to be AttributeValueIndexed, unless they include values for LARGE_ATTRIBUTE_TYPES
+
+    0. Drop the index on the AttributeValueIndexed vertex, there are no AttributeValueIndexed vertices at this point anyway
+    1. For all attributes of all schema on all branches, determine if the attribute is a LARGE_ATTRIBUTE_TYPE and when
+        attribute's kind was last updated in the schema
+    2. For all branches, starting with the default and global branches, update HAS_VALUE edges for LARGE_ATTRIBUTE_TYPE
+        attributes to point to AttributeValueNonIndexed vertices
+    3. For any LARGE_ATTRIBUTE_TYPE attributes on the default branch that were updated to non-large_type on other branches,
+        revert the HAS_VALUE edges to point to AttributeValue vertices
+    4. Add the AttributeValueIndexed label to all AttributeValue vertices
+    5. Update all AttributeValueNonIndexed vertices to AttributeValue (no AttributeValueIndexed label)
+    6. Any AttributeValueIndexed vertices with a value of size greater than MAX_STRING_LENGTH are changed to AttributeValueNonIndexed
+    7. Add the index on AttributeValueIndexed again
+    """
+
+    name: str = "036_index_attr_vals"
+    minimum_version: int = 35
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+
+        return result
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: PLR0915
+        console = Console()
+        result = MigrationResult()
+
+        # find the active schema attributes that have a LARGE_ATTRIBUTE_TYPE kind on all branches
+        console.print(
+            f"{Timestamp().to_string()} Determining schema attribute types and timestamps on all branches...", end=""
+        )
+        get_large_attribute_types_query = await GetLargeAttributeTypesQuery.init(db=db)
+        await get_large_attribute_types_query.execute(db=db)
+        schema_attribute_timeframes = get_large_attribute_types_query.get_large_attribute_type_timeframes()
+        console.print("done")
+
+        # find which schema attributes are large_types in the default branch, but updated to non-large_type on other branches
+        # {(kind, attr_name): SchemaAttributeTimeframe}
+        console.print(
+            f"{Timestamp().to_string()} Determining which schema attributes have been updated to non-large_type on non-default branches...",
+            end="",
+        )
+        main_schema_attribute_timeframes_map: dict[tuple[str, str], SchemaAttributeTimeframe] = {}
+        for schema_attr_time in schema_attribute_timeframes:
+            if schema_attr_time.is_default_branch:
+                main_schema_attribute_timeframes_map[schema_attr_time.kind, schema_attr_time.attr_name] = (
+                    schema_attr_time
+                )
+        large_type_reverts: list[SchemaAttributeTimeframe] = []
+        for schema_attr_time in schema_attribute_timeframes:
+            if schema_attr_time.is_default_branch or schema_attr_time.is_large_type:
+                continue
+            default_schema_attr_time = main_schema_attribute_timeframes_map.get(
+                (schema_attr_time.kind, schema_attr_time.attr_name)
+            )
+            if not default_schema_attr_time:
+                continue
+            if (
+                default_schema_attr_time.is_large_type
+                and default_schema_attr_time.from_time < schema_attr_time.branched_from
+            ):
+                large_type_reverts.append(schema_attr_time)
+        console.print("done")
+
+        # drop the index on the AttributeValueNonIndexed vertex, there won't be any at this point anyway
+        console.print(f"{Timestamp().to_string()} Dropping index on AttributeValueIndexed vertices...", end="")
+        index_manager = IndexManagerNeo4j(db=db)
+        index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
+        await index_manager.drop()
+        console.print("done")
+
+        # create the temporary non-indexed attribute value vertices for LARGE_ATTRIBUTE_TYPE attributes
+        # start with default branch
+        console.print(f"{Timestamp().to_string()} Update non-indexed attribute values with temporary label...", end="")
+        large_schema_attribute_timeframes = [
+            schema_attr_time for schema_attr_time in schema_attribute_timeframes if schema_attr_time.is_large_type
+        ]
+        for schema_attr_time in sorted(large_schema_attribute_timeframes, key=lambda x: x.branch_level):
+            create_non_indexed_attribute_value_query = await CreateNonIndexedAttributeValueQuery.init(
+                db=db, schema_attribute_timeframe=schema_attr_time
+            )
+            await create_non_indexed_attribute_value_query.execute(db=db)
+        console.print("done")
+
+        # re-index attribute values on branches where the type was updated to non-large_type
+        console.print(
+            f"{Timestamp().to_string()} Indexing attribute values on branches where the attribute schema was updated to a non-large_type...",
+            end="",
+        )
+        for schema_attr_time in large_type_reverts:
+            revert_non_index_on_branch_query = await RevertNonIndexOnBranchQuery.init(
+                db=db, schema_attribute_timeframe=schema_attr_time
+            )
+            await revert_non_index_on_branch_query.execute(db=db)
+        console.print("done")
+
+        # set the AttributeValue vertices to be AttributeValueIndexed
+        console.print(
+            f"{Timestamp().to_string()} Update all AttributeValue vertices to add the AttributeValueIndexed label...",
+            end="",
+        )
+        set_attribute_value_indexed_query = await SetAttributeValueIndexedQuery.init(db=db)
+        await set_attribute_value_indexed_query.execute(db=db)
+        console.print("done")
+
+        # set AttributeValueNonIndexed vertices to just AttributeValue
+        console.print(
+            f"{Timestamp().to_string()} Update all AttributeValueNonIndexed vertices to be AttributeValue (no index)...",
+            end="",
+        )
+        finalize_attribute_value_non_indexed_query = await FinalizeAttributeValueNonIndexedQuery.init(db=db)
+        await finalize_attribute_value_non_indexed_query.execute(db=db)
+        console.print("done")
+
+        # de-index all attribute values too large to be indexed
+        console.print(
+            f"{Timestamp().to_string()} De-index any legacy attribute data that is too large to be indexed...", end=""
+        )
+        de_index_large_attribute_values_query = await DeIndexLargeAttributeValuesQuery.init(
+            db=db, max_value_size=MAX_STRING_LENGTH
+        )
+        await de_index_large_attribute_values_query.execute(db=db)
+        console.print("done")
+
+        # add the index back to the AttributeValueNonIndexed vertex
+        console.print(f"{Timestamp().to_string()} Add the index back to the AttributeValueIndexed label...", end="")
+        index_manager = IndexManagerNeo4j(db=db)
+        index_manager.init(nodes=[AV_INDEXED_INDEX], rels=[])
+        await index_manager.add()
+        console.print("done")
+
+        return result

{infrahub_server-1.4.0b0.dist-info → infrahub_server-1.4.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.4.0b0
+Version: 1.4.0b1
 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.
 License: Apache-2.0
 Author: OpsMill
@@ -19,6 +19,7 @@ Requires-Dist: asgi-correlation-id (==4.2.0)
 Requires-Dist: authlib (==1.3.2)
 Requires-Dist: bcrypt (>=4.1,<4.2)
 Requires-Dist: boto3 (==1.34.129)
+Requires-Dist: copier (>=9.8.0,<10.0.0)
 Requires-Dist: dulwich (>=0.22.7,<0.23.0)
 Requires-Dist: email-validator (>=2.1,<2.2)
 Requires-Dist: fast-depends (>=2.4.12,<3.0.0)

{infrahub_server-1.4.0b0.dist-info → infrahub_server-1.4.0b1.dist-info}/RECORD

@@ -137,7 +137,7 @@ infrahub/core/diff/repository/deserializer.py,sha256=bhN9ao8HxqKyRz273QGLNV9z9_S
 infrahub/core/diff/repository/repository.py,sha256=u0QTMY1e2dknG_DuRAwzFt-Lp1_mdj5lqF2ymt77k9E,25581
 infrahub/core/diff/tasks.py,sha256=jSXlenTJ5Fc189Xvm971e3-gBDRnfN19cxNaWvEFwAE,3306
 infrahub/core/enums.py,sha256=qGbhRVoH43Xi0iDkUfWdQiKapJbLT9UKsCobFk_paIk,491
-infrahub/core/graph/__init__.py,sha256=p_rrdGMj53zA-RqJP0K9pTThqOxMPg80Yqgor2gc7iA,19
+infrahub/core/graph/__init__.py,sha256=tsz9YAARJcOVdEpuPKe6HoQi-uEbOAckrhbJQsa8PwM,19
 infrahub/core/graph/constraints.py,sha256=lmuzrKDFoeSKRiLtycB9PXi6zhMYghczKrPYvfWyy90,10396
 infrahub/core/graph/index.py,sha256=A9jzEE_wldBJsEsflODeMt4GM8sPmmbHAJRNdFioR1k,1736
 infrahub/core/graph/schema.py,sha256=o50Jcy6GBRk55RkDJSMIDDwHhLD7y_RWOirI9rCex4A,10776
@@ -156,7 +156,7 @@ infrahub/core/ipam/utilization.py,sha256=d-zpXCaWsHgJxBLopCDd7y4sJYvHcIzzpYhbTMI
 infrahub/core/manager.py,sha256=NaUuSY7Veesa67epQRuQ2TJD0-ooUSnvNRIUZCntV3g,47576
 infrahub/core/merge.py,sha256=TNZpxjNYcl3dnvE8eYXaWSXFDYeEa8DDsS9XbR2XKlA,11217
 infrahub/core/migrations/__init__.py,sha256=syPb3-Irf11dXCHgbT0UdmTnEBbpf4wXJ3m8ADYXDpk,1175
-infrahub/core/migrations/graph/__init__.py,sha256=JjFM4BpAeCYGB69_1j8zUItme4dUx0uTLW1uzBCRc1E,3956
+infrahub/core/migrations/graph/__init__.py,sha256=q43iviiqSx7Aiml46u-zlxFYTTpNoCySfra5A30P3NU,4021
 infrahub/core/migrations/graph/m001_add_version_to_graph.py,sha256=YcLN6cFjE6IGheXR4Ujb6CcyY8bJ7WE289hcKJaENOc,1515
 infrahub/core/migrations/graph/m002_attribute_is_default.py,sha256=wB6f2N_ChTvGajqHD-OWCG5ahRMDhhXZuwo79ieq_II,1036
 infrahub/core/migrations/graph/m003_relationship_parent_optional.py,sha256=Aya-s98XfE9C7YluOwEjilwgnjaBnZxp27w_Xdv_NmU,2330
@@ -192,6 +192,7 @@ infrahub/core/migrations/graph/m032_cleanup_orphaned_branch_relationships.py,sha
 infrahub/core/migrations/graph/m033_deduplicate_relationship_vertices.py,sha256=EHsNyYEPYzqMybgrMefvE9tw-WUWmnh9ZF8FMVRl2wQ,3735
 infrahub/core/migrations/graph/m034_find_orphaned_schema_fields.py,sha256=FekohfsamyLNzGBeRBiZML94tz2fUcvTzttfv6mD1cw,3547
 infrahub/core/migrations/graph/m035_drop_attr_value_index.py,sha256=iAWLeKH6F1Zs4lS_3BmLI8K54xCriSXOrwdpNdNa7P0,1439
+infrahub/core/migrations/graph/m036_index_attr_vals.py,sha256=PGbCYU3gqveOI1jl7T18DLTYRuLedbKysaP0-3k13k0,22730
 infrahub/core/migrations/query/__init__.py,sha256=JoWOUWlV6IzwxWxObsfCnAAKUOHJkE7dZlOsfB64ZEo,876
 infrahub/core/migrations/query/attribute_add.py,sha256=oitzB-PPAclfyNtcwCWJY3RdI5Zi4oEnR62BDzn1UQk,4835
 infrahub/core/migrations/query/attribute_rename.py,sha256=onb9Nanht1Tz47JgneAcFsuhqqvPS6dvI2nNjRupLLo,6892
@@ -821,8 +822,8 @@ infrahub_testcontainers/models.py,sha256=ASYyvl7d_WQz_i7y8-3iab9hwwmCl3OCJavqVbe
 infrahub_testcontainers/performance_test.py,sha256=hvwiy6tc_lWniYqGkqfOXVGAmA_IV15VOZqbiD9ezno,6149
 infrahub_testcontainers/plugin.py,sha256=I3RuZQ0dARyKHuqCf0y1Yj731P2Mwf3BJUehRJKeWrs,5645
 infrahub_testcontainers/prometheus.yml,sha256=610xQEyj3xuVJMzPkC4m1fRnCrjGpiRBrXA2ytCLa54,599
-infrahub_server-1.4.0b0.dist-info/LICENSE.txt,sha256=7GQO7kxVoQYnZtFrjZBKLRXbrGwwwimHPPOJtqXsozQ,11340
-infrahub_server-1.4.0b0.dist-info/METADATA,sha256=FL6nu_RKVWmzV8PitKhPGzm-1mA_g9xomm4acDvTOfQ,8238
-infrahub_server-1.4.0b0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-infrahub_server-1.4.0b0.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
-infrahub_server-1.4.0b0.dist-info/RECORD,,
+infrahub_server-1.4.0b1.dist-info/LICENSE.txt,sha256=7GQO7kxVoQYnZtFrjZBKLRXbrGwwwimHPPOJtqXsozQ,11340
+infrahub_server-1.4.0b1.dist-info/METADATA,sha256=z_kgqH-ShqI6ud1WaOWBF4ZSkDYdouIw-ZuAKyiRB2I,8278
+infrahub_server-1.4.0b1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+infrahub_server-1.4.0b1.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
+infrahub_server-1.4.0b1.dist-info/RECORD,,