infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/schema/basenode_schema.py

@@ -4,7 +4,8 @@ import hashlib
 import keyword
 import os
 from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, Optional, Union, overload
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
@@ -24,6 +25,7 @@ if TYPE_CHECKING:
 
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
+INHERITED = "INHERITED"
 
 
 class BaseNodeSchema(GeneratedBaseNodeSchema):
@@ -62,6 +64,17 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         Be careful hash generated from hash() have a salt by default and they will not be the same across run"""
         return hash(self.get_hash())
 
+    def to_dict(self) -> dict:
+        data = self.model_dump(
+            exclude_unset=True, exclude_none=True, exclude_defaults=True, exclude={"attributes", "relationships"}
+        )
+        for field_name, value in data.items():
+            if isinstance(value, Enum):
+                data[field_name] = value.value
+        data["attributes"] = [attr.to_dict() for attr in self.attributes]
+        data["relationships"] = [rel.to_dict() for rel in self.relationships]
+        return data
+
     def get_hash(self, display_values: bool = False) -> str:
         """Extend the Hash Calculation to account for attributes and relationships."""
 
@@ -108,7 +121,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         other: Self,
         get_func: Callable,
         get_map_func: Callable,
-        obj_type: type[Union[AttributeSchema, RelationshipSchema]],
+        obj_type: type[AttributeSchema | RelationshipSchema],
     ) -> HashableModelDiff:
         """The goal of this function is to reduce the amount of code duplicated between Attribute and Relationship to calculate a diff
         The logic is the same for both, except that the functions we are using to access these objects are differents
@@ -126,8 +139,8 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         reversed_map_other = dict(map(reversed, other_map.items()))
 
         # Identify which elements are using the same id on both sides
-        clean_local_ids = [id for id in local_map.values() if id is not None]
-        clean_other_ids = [id for id in other_map.values() if id is not None]
+        clean_local_ids = [id for id in local_map.values() if id is not None and id != INHERITED]
+        clean_other_ids = [id for id in other_map.values() if id is not None and id != INHERITED]
         shared_ids = intersection(list1=clean_local_ids, list2=clean_other_ids)
 
         # Identify which elements are present on both side based on the name
@@ -164,16 +177,14 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         return elements_diff
 
     @overload
-    def get_field(
-        self, name: str, raise_on_error: Literal[True] = True
-    ) -> Union[AttributeSchema, RelationshipSchema]: ...
+    def get_field(self, name: str, raise_on_error: Literal[True] = True) -> AttributeSchema | RelationshipSchema: ...
 
     @overload
     def get_field(
         self, name: str, raise_on_error: Literal[False] = False
-    ) -> Optional[Union[AttributeSchema, RelationshipSchema]]: ...
+    ) -> AttributeSchema | RelationshipSchema | None: ...
 
-    def get_field(self, name: str, raise_on_error: bool = True) -> Optional[Union[AttributeSchema, RelationshipSchema]]:
+    def get_field(self, name: str, raise_on_error: bool = True) -> AttributeSchema | RelationshipSchema | None:
         if field := self.get_attribute_or_none(name=name):
             return field
 
@@ -192,7 +203,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         raise ValueError(f"Unable to find the attribute {name}")
 
-    def get_attribute_or_none(self, name: str) -> Optional[AttributeSchema]:
+    def get_attribute_or_none(self, name: str) -> AttributeSchema | None:
         for item in self.attributes:
             if item.name == name:
                 return item
@@ -218,7 +229,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         raise ValueError(f"Unable to find the relationship with the ID: {id}")
 
-    def get_relationship_or_none(self, name: str) -> Optional[RelationshipSchema]:
+    def get_relationship_or_none(self, name: str) -> RelationshipSchema | None:
         for item in self.relationships:
             if item.name == name:
                 return item
@@ -230,9 +241,9 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     @overload
     def get_relationship_by_identifier(
         self, id: str, raise_on_error: Literal[False] = False
-    ) -> Optional[RelationshipSchema]: ...
+    ) -> RelationshipSchema | None: ...
 
-    def get_relationship_by_identifier(self, id: str, raise_on_error: bool = True) -> Optional[RelationshipSchema]:
+    def get_relationship_by_identifier(self, id: str, raise_on_error: bool = True) -> RelationshipSchema | None:
         for item in self.relationships:
             if item.identifier == id:
                 return item
@@ -257,13 +268,13 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def get_attributes_name_id_map(self) -> dict[str, str]:
         name_id_map = {}
         for attr in self.attributes:
-            name_id_map[attr.name] = attr.id
+            name_id_map[attr.name] = INHERITED if attr.inherited else attr.id
         return name_id_map
 
     def get_relationship_name_id_map(self) -> dict[str, str]:
         name_id_map = {}
         for rel in self.relationships:
-            name_id_map[rel.name] = rel.id
+            name_id_map[rel.name] = INHERITED if rel.inherited else rel.id
         return name_id_map
 
     @property
@@ -331,7 +342,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             fields[subpaths[0]] = cls.convert_path_to_graphql_fields(path=subpaths[1])
         return fields
 
-    def generate_fields_for_display_label(self) -> Optional[dict]:
+    def generate_fields_for_display_label(self) -> dict | None:
         """Generate a dictionary containing the list of fields that are required
         to generate the display_label.
 
@@ -341,12 +352,12 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.display_labels:
             return None
 
-        fields: dict[str, Union[str, None, dict[str, None]]] = {}
+        fields: dict[str, str | None | dict[str, None]] = {}
         for item in self.display_labels:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
 
-    def generate_fields_for_hfid(self) -> Optional[dict]:
+    def generate_fields_for_hfid(self) -> dict | None:
         """Generate a dictionary containing the list of fields that are required
         to generate the hfid.
 
@@ -356,7 +367,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.human_friendly_id:
             return None
 
-        fields: dict[str, Union[str, None, dict[str, None]]] = {}
+        fields: dict[str, str | None | dict[str, None]] = {}
         for item in self.human_friendly_id:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
@@ -369,11 +380,11 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         return value
 
-    def parse_schema_path(self, path: str, schema: Optional[SchemaBranch] = None) -> SchemaAttributePath:
+    def parse_schema_path(self, path: str, schema: SchemaBranch | None = None) -> SchemaAttributePath:
         schema_path = SchemaAttributePath()
-        relationship_piece: Optional[str] = None
-        attribute_piece: Optional[str] = None
-        property_piece: Optional[str] = None
+        relationship_piece: str | None = None
+        attribute_piece: str | None = None
+        property_piece: str | None = None
 
         path_parts = path.split("__")
         if path_parts[0] in self.relationship_names:
@@ -422,33 +433,79 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def get_unique_constraint_schema_attribute_paths(
         self,
         schema_branch: SchemaBranch,
-        include_unique_attributes: bool = False,
-    ) -> list[list[SchemaAttributePath]]:
-        constraint_paths_groups = []
-        if include_unique_attributes:
-            for attribute_schema in self.unique_attributes:
-                constraint_paths_groups.append(
-                    [SchemaAttributePath(attribute_schema=attribute_schema, attribute_property_name="value")]
-                )
-
-        if not self.uniqueness_constraints:
-            return constraint_paths_groups
+    ) -> list[SchemaUniquenessConstraintPath]:
+        if self.uniqueness_constraints is None:
+            return []
+
+        uniqueness_constraint_paths = []
 
         for uniqueness_path_group in self.uniqueness_constraints:
-            constraint_paths_group = []
-            for uniqueness_path_part in uniqueness_path_group:
-                constraint_paths_group.append(self.parse_schema_path(path=uniqueness_path_part, schema=schema_branch))
-            if constraint_paths_group not in constraint_paths_groups:
-                constraint_paths_groups.append(constraint_paths_group)
-        return constraint_paths_groups
+            attributes_paths = [
+                self.parse_schema_path(path=uniqueness_path_part, schema=schema_branch)
+                for uniqueness_path_part in uniqueness_path_group
+            ]
+            uniqueness_constraint_type = self.get_uniqueness_constraint_type(
+                uniqueness_constraint=set(uniqueness_path_group), schema_branch=schema_branch
+            )
+            uniqueness_constraint_path = SchemaUniquenessConstraintPath(
+                attributes_paths=attributes_paths, typ=uniqueness_constraint_type
+            )
+            uniqueness_constraint_paths.append(uniqueness_constraint_path)
+
+        return uniqueness_constraint_paths
+
+    def convert_hfid_to_uniqueness_constraint(self, schema_branch: SchemaBranch) -> list[str] | None:
+        if self.human_friendly_id is None:
+            return None
+
+        uniqueness_constraint = []
+        for item in self.human_friendly_id:
+            schema_attribute_path = self.parse_schema_path(path=item, schema=schema_branch)
+            if schema_attribute_path.is_type_attribute:
+                uniqueness_constraint.append(item)
+            elif schema_attribute_path.is_type_relationship:
+                uniqueness_constraint.append(schema_attribute_path.relationship_schema.name)
+        return uniqueness_constraint
+
+    def get_uniqueness_constraint_type(
+        self, uniqueness_constraint: set[str], schema_branch: SchemaBranch
+    ) -> UniquenessConstraintType:
+        hfid = self.convert_hfid_to_uniqueness_constraint(schema_branch=schema_branch)
+        if hfid is None:
+            return UniquenessConstraintType.STANDARD
+        hfid_set = set(hfid)
+        if uniqueness_constraint == hfid_set:
+            return UniquenessConstraintType.HFID
+        if uniqueness_constraint <= hfid_set:
+            return UniquenessConstraintType.SUBSET_OF_HFID
+        return UniquenessConstraintType.STANDARD
+
+
+@dataclass
+class SchemaUniquenessConstraintPath:
+    attributes_paths: list[SchemaAttributePath]
+    typ: UniquenessConstraintType
+
+
+class UniquenessConstraintType(Enum):
+    HFID = "HFID"
+    SUBSET_OF_HFID = "SUBSET_OF_HFID"
+    STANDARD = "STANDARD"
+
+
+@dataclass
+class UniquenessConstraintViolation:
+    nodes_ids: set[str]
+    fields: list[str]
+    typ: UniquenessConstraintType
 
 
 @dataclass
 class SchemaAttributePath:
-    relationship_schema: Optional[RelationshipSchema] = None
-    related_schema: Optional[Union[NodeSchema, GenericSchema]] = None
-    attribute_schema: Optional[AttributeSchema] = None
-    attribute_property_name: Optional[str] = None
+    relationship_schema: RelationshipSchema | None = None
+    related_schema: NodeSchema | GenericSchema | None = None
+    attribute_schema: AttributeSchema | None = None
+    attribute_property_name: str | None = None
 
     @property
     def is_type_attribute(self) -> bool:
@@ -480,6 +537,10 @@ class SchemaAttributePath:
             return self.attribute_property_name
         raise AttributePathParsingError("An attribute_property_name was expected but not found")
 
+    @property
+    def attribute_path_as_str(self) -> str:
+        return self.active_attribute_schema.name + "__" + self.active_attribute_property_name
+
 
 @dataclass
 class SchemaAttributePathValue(SchemaAttributePath):

infrahub/core/schema/computed_attribute.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import ConfigDict, Field, model_serializer
 
@@ -8,10 +8,10 @@ from infrahub.core.models import HashableModel
 
 class ComputedAttribute(HashableModel):
     kind: ComputedAttributeKind
-    jinja2_template: Optional[str] = Field(
+    jinja2_template: str | None = Field(
         default=None, description="The Jinja2 template in string format, required when assignment_type=jinja2"
     )
-    transform: Optional[str] = Field(
+    transform: str | None = Field(
         default=None, description="The Python Transform name or ID, required when assignment_type=transform"
     )
 

infrahub/core/schema/definitions/core/__init__.py

@@ -0,0 +1,147 @@
+from typing import Any
+
+from ...generic_schema import GenericSchema
+from ...node_schema import NodeSchema
+from .account import (
+    core_account,
+    core_account_token,
+    core_credential,
+    core_generic_account,
+    core_password_credential,
+    core_refresh_token,
+)
+from .artifact import core_artifact, core_artifact_definition, core_artifact_target
+from .builtin import builtin_tag
+from .check import core_check_definition
+from .core import core_node, core_task_target
+from .generator import core_generator_definition, core_generator_instance
+from .graphql_query import core_graphql_query
+from .group import core_generator_group, core_graphql_query_group, core_group, core_standard_group
+from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
+from .lineage import lineage_owner, lineage_source
+from .menu import generic_menu_item, menu_item
+from .permission import (
+    core_account_group,
+    core_account_role,
+    core_base_permission,
+    core_global_permission,
+    core_object_permission,
+)
+from .profile import core_profile_schema_definition
+from .propose_change import core_proposed_change
+from .propose_change_comment import (
+    core_artifact_thread,
+    core_change_comment,
+    core_change_thread,
+    core_file_thread,
+    core_object_thread,
+    core_propose_change_comment,
+    core_thread,
+    core_thread_comment,
+)
+from .propose_change_validator import (
+    core_artifact_check,
+    core_artifact_validator,
+    core_check,
+    core_data_check,
+    core_data_validator,
+    core_file_check,
+    core_generator_check,
+    core_generator_validator,
+    core_propose_change_validator,
+    core_repository_validator,
+    core_schema_check,
+    core_schema_validator,
+    core_standard_check,
+    core_user_validator,
+)
+from .repository import core_generic_repository, core_read_only_repository, core_repository
+from .resource_pool import core_ip_address_pool, core_ip_prefix_pool, core_number_pool, core_resource_pool
+from .template import core_object_component_template, core_object_template
+from .transform import core_transform, core_transform_jinja2, core_transform_python
+from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
+
+core_models_mixed: dict[str, list] = {
+    "generics": [
+        core_node,
+        lineage_owner,
+        core_profile_schema_definition,
+        lineage_source,
+        core_propose_change_comment,
+        core_thread,
+        core_group,
+        core_propose_change_validator,
+        core_check,
+        core_transform,
+        core_artifact_target,
+        core_task_target,
+        core_webhook,
+        core_generic_repository,
+        builtin_ipam,
+        builtin_ip_prefix,
+        builtin_ip_address,
+        core_resource_pool,
+        core_generic_account,
+        core_base_permission,
+        core_credential,
+        core_object_template,
+        core_object_component_template,
+        generic_menu_item,
+    ],
+    "nodes": [
+        menu_item,
+        core_standard_group,
+        core_generator_group,
+        core_graphql_query_group,
+        builtin_tag,
+        core_account,
+        core_account_token,
+        core_password_credential,
+        core_refresh_token,
+        core_proposed_change,
+        core_change_thread,
+        core_file_thread,
+        core_artifact_thread,
+        core_object_thread,
+        core_change_comment,
+        core_thread_comment,
+        core_repository,
+        core_read_only_repository,
+        core_transform_jinja2,
+        core_data_check,
+        core_standard_check,
+        core_schema_check,
+        core_file_check,
+        core_artifact_check,
+        core_generator_check,
+        core_data_validator,
+        core_repository_validator,
+        core_user_validator,
+        core_schema_validator,
+        core_artifact_validator,
+        core_generator_validator,
+        core_check_definition,
+        core_transform_python,
+        core_graphql_query,
+        core_artifact,
+        core_artifact_definition,
+        core_generator_definition,
+        core_generator_instance,
+        core_standard_webhook,
+        core_custom_webhook,
+        core_ipam_namespace,
+        core_ip_prefix_pool,
+        core_ip_address_pool,
+        core_number_pool,
+        core_global_permission,
+        core_object_permission,
+        core_account_role,
+        core_account_group,
+    ],
+}
+
+
+core_models: dict[str, Any] = {
+    "generics": [item.to_dict() if isinstance(item, GenericSchema) else item for item in core_models_mixed["generics"]],
+    "nodes": [item.to_dict() if isinstance(item, NodeSchema) else item for item in core_models_mixed["nodes"]],
+}

infrahub/core/schema/definitions/core/account.py

@@ -0,0 +1,171 @@
+from infrahub.core.constants import (
+    AccountStatus,
+    AccountType,
+    BranchSupportType,
+    InfrahubKind,
+)
+from infrahub.core.constants import RelationshipCardinality as Cardinality
+
+from ...attribute_schema import AttributeSchema as Attr
+from ...dropdown import DropdownChoice
+from ...generic_schema import GenericSchema
+from ...node_schema import NodeSchema
+from ...relationship_schema import (
+    RelationshipSchema as Rel,
+)
+
+core_account = NodeSchema(
+    name="Account",
+    namespace="Core",
+    description="User Account for Infrahub",
+    include_in_menu=False,
+    label="Account",
+    icon="mdi:account",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["label__value"],
+    generate_profile=False,
+    branch=BranchSupportType.AGNOSTIC,
+    inherit_from=[InfrahubKind.LINEAGEOWNER, InfrahubKind.LINEAGESOURCE, InfrahubKind.GENERICACCOUNT],
+)
+
+core_account_token = NodeSchema(
+    name="AccountToken",
+    namespace="Internal",
+    description="Token for User Account",
+    include_in_menu=False,
+    label="Account Token",
+    default_filter="token__value",
+    display_labels=["token__value"],
+    generate_profile=False,
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["token__value"]],
+    documentation="/topics/auth",
+    attributes=[
+        Attr(name="name", kind="Text", optional=True),
+        Attr(name="token", kind="Text", unique=True),
+        Attr(name="expiration", kind="DateTime", optional=True),
+    ],
+    relationships=[
+        Rel(
+            name="account",
+            peer=InfrahubKind.GENERICACCOUNT,
+            optional=False,
+            cardinality=Cardinality.ONE,
+            identifier="account__token",
+        ),
+    ],
+)
+
+core_password_credential = NodeSchema(
+    name="PasswordCredential",
+    namespace="Core",
+    description="Username/Password based credential",
+    include_in_menu=False,
+    label="Username / Password",
+    generate_profile=False,
+    branch=BranchSupportType.AGNOSTIC,
+    inherit_from=[InfrahubKind.CREDENTIAL],
+    attributes=[
+        Attr(name="username", kind="Text", optional=True, branch=BranchSupportType.AGNOSTIC, order_weight=6000),
+        Attr(
+            name="password",
+            kind="Password",
+            optional=True,
+            branch=BranchSupportType.AGNOSTIC,
+            order_weight=7000,
+        ),
+    ],
+)
+
+core_refresh_token = NodeSchema(
+    name="RefreshToken",
+    namespace="Internal",
+    description="Refresh Token",
+    include_in_menu=False,
+    label="Refresh Token",
+    display_labels=[],
+    generate_profile=False,
+    branch=BranchSupportType.AGNOSTIC,
+    attributes=[
+        Attr(name="expiration", kind="DateTime", optional=False),
+    ],
+    relationships=[
+        Rel(
+            name="account",
+            peer=InfrahubKind.GENERICACCOUNT,
+            optional=False,
+            cardinality=Cardinality.ONE,
+            identifier="account__refreshtoken",
+        ),
+    ],
+)
+
+core_credential = GenericSchema(
+    name="Credential",
+    namespace="Core",
+    description="A credential that could be referenced to access external services.",
+    include_in_menu=False,
+    label="Credential",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["label__value"],
+    icon="mdi:key-variant",
+    human_friendly_id=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    uniqueness_constraints=[["name__value"]],
+    documentation="/topics/auth",
+    attributes=[
+        Attr(name="name", kind="Text", unique=True, order_weight=1000),
+        Attr(name="label", kind="Text", optional=True, order_weight=2000),
+        Attr(name="description", kind="Text", optional=True, order_weight=3000),
+    ],
+)
+
+core_generic_account = GenericSchema(
+    name="GenericAccount",
+    namespace="Core",
+    description="User Account for Infrahub",
+    include_in_menu=False,
+    label="Account",
+    icon="mdi:account",
+    default_filter="name__value",
+    order_by=["name__value"],
+    display_labels=["label__value"],
+    human_friendly_id=["name__value"],
+    branch=BranchSupportType.AGNOSTIC,
+    documentation="/topics/auth",
+    uniqueness_constraints=[["name__value"]],
+    attributes=[
+        Attr(name="name", kind="Text", unique=True),
+        Attr(name="password", kind="HashedPassword", unique=False),
+        Attr(name="label", kind="Text", optional=True),
+        Attr(name="description", kind="Text", optional=True),
+        Attr(
+            name="account_type",
+            kind="Text",
+            default_value=AccountType.USER.value,
+            enum=AccountType.available_types(),
+        ),
+        Attr(
+            name="status",
+            kind="Dropdown",
+            choices=[
+                DropdownChoice(
+                    name=AccountStatus.ACTIVE.value,
+                    label="Active",
+                    description="Account is allowed to login",
+                    color="#52be80",
+                ),
+                DropdownChoice(
+                    name=AccountStatus.INACTIVE.value,
+                    label="Inactive",
+                    description="Account is not allowed to login",
+                    color="#e74c3c",
+                ),
+            ],
+            default_value=AccountStatus.ACTIVE.value,
+        ),
+    ],
+    relationships=[Rel(name="tokens", peer=InfrahubKind.ACCOUNTTOKEN, optional=True, cardinality=Cardinality.MANY)],
+)