infrahub-server 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub_sdk/config.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import ssl
 from copy import deepcopy
 from typing import Any
 
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, PrivateAttr, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing_extensions import Self
 
@@ -78,6 +79,7 @@ class ConfigBase(BaseSettings):
     Can be useful to test with self-signed certificates.""",
     )
     tls_ca_file: str | None = Field(default=None, description="File path to CA cert or bundle in PEM format")
+    _ssl_context: ssl.SSLContext | None = PrivateAttr(default=None)
 
     @model_validator(mode="before")
     @classmethod
@@ -133,6 +135,28 @@ class ConfigBase(BaseSettings):
     def password_authentication(self) -> bool:
         return bool(self.username)
 
+    @property
+    def tls_context(self) -> ssl.SSLContext:
+        if self._ssl_context:
+            return self._ssl_context
+
+        if self.tls_insecure:
+            self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            self._ssl_context.check_hostname = False
+            self._ssl_context.verify_mode = ssl.CERT_NONE
+            return self._ssl_context
+
+        if self.tls_ca_file:
+            self._ssl_context = ssl.create_default_context(cafile=self.tls_ca_file)
+
+        if self._ssl_context is None:
+            self._ssl_context = ssl.create_default_context()
+
+        return self._ssl_context
+
+    def set_ssl_context(self, context: ssl.SSLContext) -> None:
+        self._ssl_context = context
+
 
 class Config(ConfigBase):
     recorder: RecorderType = Field(default=RecorderType.NONE, description="Select builtin recorder for later replay.")
@@ -174,4 +198,7 @@ class Config(ConfigBase):
             if field not in covered_keys:
                 config[field] = deepcopy(getattr(self, field))
 
-        return Config(**config)
+        new_config = Config(**config)
+        if self._ssl_context:
+            new_config.set_ssl_context(self._ssl_context)
+        return new_config

infrahub_sdk/convert_object_type.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, model_validator
+
+CONVERT_OBJECT_MUTATION = """
+    mutation($node_id: String!, $target_kind: String!, $fields_mapping: GenericScalar!) {
+        ConvertObjectType(data: {
+                node_id: $node_id,
+                target_kind: $target_kind,
+                fields_mapping: $fields_mapping
+            }) {
+                ok
+                node
+        }
+    }
+"""
+
+
+class ConversionFieldValue(BaseModel):  # Only one of these fields can be not None
+    """
+    Holds the new value of the destination field during an object conversion.
+    Use `attribute_value` to specify the new raw value of an attribute.
+    Use `peer_id` to specify new peer of a cardinality one relationship.
+    Use `peers_ids` to specify new peers of a cardinality many relationship.
+    Only one of `attribute_value`, `peer_id` and `peers_ids` can be specified.
+    """
+
+    attribute_value: Any | None = None
+    peer_id: str | None = None
+    peers_ids: list[str] | None = None
+
+    @model_validator(mode="after")
+    def check_only_one_field(self) -> ConversionFieldValue:
+        fields = [self.attribute_value, self.peer_id, self.peers_ids]
+        set_fields = [f for f in fields if f is not None]
+        if len(set_fields) != 1:
+            raise ValueError("Exactly one of `attribute_value`, `peer_id`, or `peers_ids` must be set")
+        return self
+
+
+class ConversionFieldInput(BaseModel):
+    """
+    Indicates how to fill in the value of the destination field during an object conversion.
+    Use `source_field` to reuse the value of the corresponding field of the object being converted.
+    Use `data` to specify the new value for the field.
+    Use `use_default_value` to set the destination field to its schema default.
+    Only one of `source_field`, `data`, or `use_default_value` can be specified.
+    """
+
+    source_field: str | None = None
+    data: ConversionFieldValue | None = None
+    use_default_value: bool = False
+
+    @model_validator(mode="after")
+    def check_only_one_field(self) -> ConversionFieldInput:
+        fields_set = [self.source_field is not None, self.data is not None, self.use_default_value is True]
+        if sum(fields_set) != 1:
+            raise ValueError("Exactly one of `source_field`, `data` or `use_default_value` must be set")
+        return self

infrahub_sdk/ctl/branch.py

@@ -46,6 +46,7 @@ async def list_branch(_: str = CONFIG_PARAM) -> None:
     table.add_column("Sync with Git")
     table.add_column("Has Schema Changes")
     table.add_column("Is Default")
+    table.add_column("Status")
 
     # identify the default branch and always print it first
     default_branch = [branch for branch in branches.values() if branch.is_default][0]
@@ -57,6 +58,7 @@ async def list_branch(_: str = CONFIG_PARAM) -> None:
         "[green]True" if default_branch.sync_with_git else "[#FF7F50]False",
         "[green]True" if default_branch.has_schema_changes else "[#FF7F50]False",
         "[green]True" if default_branch.is_default else "[#FF7F50]False",
+        default_branch.status,
     )
 
     for branch in branches.values():
@@ -71,6 +73,7 @@ async def list_branch(_: str = CONFIG_PARAM) -> None:
             "[green]True" if branch.sync_with_git else "[#FF7F50]False",
             "[green]True" if default_branch.has_schema_changes else "[#FF7F50]False",
             "[green]True" if branch.is_default else "[#FF7F50]False",
+            branch.status,
         )
 
     console.print(table)

infrahub_sdk/ctl/check.py

@@ -11,10 +11,9 @@ import typer
 from rich.console import Console
 from rich.logging import RichHandler
 
-from ..ctl import config
 from ..ctl.client import initialize_client
 from ..ctl.exceptions import QueryNotFoundError
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.utils import catch_exception, execute_graphql_query
 from ..exceptions import ModuleImportError
 
@@ -59,7 +58,7 @@ def run(
     FORMAT = "%(message)s"
     logging.basicConfig(level=log_level, format=FORMAT, datefmt="[%X]", handlers=[RichHandler()])
 
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available:
         list_checks(repository_config=repository_config)

infrahub_sdk/ctl/cli_commands.py

@@ -20,18 +20,19 @@ from rich.table import Table
 
 from .. import __version__ as sdk_version
 from ..async_typer import AsyncTyper
-from ..ctl import config
 from ..ctl.branch import app as branch_app
 from ..ctl.check import run as run_check
 from ..ctl.client import initialize_client, initialize_client_sync
 from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.generator import run as run_generator
+from ..ctl.graphql import app as graphql_app
 from ..ctl.menu import app as menu_app
 from ..ctl.object import app as object_app
 from ..ctl.render import list_jinja2_transforms, print_template_errors
 from ..ctl.repository import app as repository_app
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.schema import app as schema_app
+from ..ctl.task import app as task_app
 from ..ctl.transform import list_transforms
 from ..ctl.utils import (
     catch_exception,
@@ -46,7 +47,7 @@ from ..protocols_generator.generator import CodeGenerator
 from ..schema import MainSchemaTypesAll, SchemaRoot
 from ..template import Jinja2Template
 from ..template.exceptions import JinjaTemplateError
-from ..utils import get_branch, write_to_file
+from ..utils import write_to_file
 from ..yaml import SchemaFile
 from .exporter import dump
 from .importer import load
@@ -63,6 +64,8 @@ app.add_typer(validate_app, name="validate")
 app.add_typer(repository_app, name="repository")
 app.add_typer(menu_app, name="menu")
 app.add_typer(object_app, name="object")
+app.add_typer(graphql_app, name="graphql")
+app.add_typer(task_app, name="task")
 
 app.command(name="dump")(dump)
 app.command(name="load")(load)
@@ -208,7 +211,6 @@ async def _run_transform(
         debug: Prints debug info to the command line
         repository_config: Repository config object. This is used to load the graphql query from the repository.
     """
-    branch = get_branch(branch)
 
     try:
         response = execute_graphql_query(
@@ -260,7 +262,7 @@ async def render(
     """Render a local Jinja2 Transform for debugging purpose."""
 
     variables_dict = parse_cli_vars(variables)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not transform_name:
         list_jinja2_transforms(config=repository_config)
@@ -270,7 +272,7 @@ async def render(
     try:
         transform_config = repository_config.get_jinja2_transform(name=transform_name)
     except KeyError as exc:
-        console.print(f'[red]Unable to find "{transform_name}" in {config.INFRAHUB_REPO_CONFIG_FILE}')
+        console.print(f'[red]Unable to find "{transform_name}" in repository config file')
         list_jinja2_transforms(config=repository_config)
         raise typer.Exit(1) from exc
 
@@ -310,7 +312,7 @@ def transform(
     """Render a local transform (TransformPython) for debugging purpose."""
 
     variables_dict = parse_cli_vars(variables)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not transform_name:
         list_transforms(config=repository_config)
@@ -409,7 +411,6 @@ def info(  # noqa: PLR0915
     _: str = CONFIG_PARAM,
 ) -> None:
     """Display the status of the Python SDK."""
-
     info: dict[str, Any] = {
         "error": None,
         "status": ":x:",
@@ -417,12 +418,17 @@ def info(  # noqa: PLR0915
         "user_info": {},
         "groups": {},
     }
+    client = initialize_client_sync()
+    fetch_user_details = bool(client.config.username) or bool(client.config.api_token)
+
     try:
-        client = initialize_client_sync()
         info["infrahub_version"] = client.get_version()
-        info["user_info"] = client.get_user()
+
+        if fetch_user_details:
+            info["user_info"] = client.get_user()
+            info["groups"] = client.get_user_permissions()
+
         info["status"] = ":white_heavy_check_mark:"
-        info["groups"] = client.get_user_permissions()
     except Exception as e:
         info["error"] = f"{e!s} ({e.__class__.__name__})"
 
@@ -469,7 +475,7 @@ def info(  # noqa: PLR0915
         pretty_model = Pretty(client.config.model_dump(), expand_all=True)
         layout["client_info"].update(Panel(pretty_model, title="Client Info"))
 
-        # Infrahub information planel
+        # Infrahub information panel
         infrahub_info = Table(show_header=False, box=None)
         if info["user_info"]:
             infrahub_info.add_row("User:", info["user_info"]["AccountProfile"]["display_label"])
@@ -487,6 +493,8 @@ def info(  # noqa: PLR0915
                 infrahub_info.add_row("Groups:", "")
                 for group, roles in groups.items():
                     infrahub_info.add_row("", group, ", ".join(roles))
+        else:
+            infrahub_info.add_row("User:", "anonymous")
 
         layout["infrahub_info"].update(Panel(infrahub_info, title="Infrahub Info"))
 

infrahub_sdk/ctl/config.py

@@ -2,16 +2,22 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 
-import toml
 import typer
 from pydantic import Field, ValidationError, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
 DEFAULT_CONFIG_FILE = "infrahubctl.toml"
 ENVVAR_CONFIG_FILE = "INFRAHUBCTL_CONFIG"
 INFRAHUB_REPO_CONFIG_FILE = ".infrahub.yml"
+INFRAHUB_REPO_CONFIG_FILE_ALT = ".infrahub.yaml"
 
 
 class Settings(BaseSettings):
@@ -59,7 +65,7 @@ class ConfiguredSettings:
 
         if config_file.is_file():
             config_string = config_file.read_text(encoding="utf-8")
-            config_tmp = toml.loads(config_string)
+            config_tmp = tomllib.loads(config_string)
 
             self._settings = Settings(**config_tmp)
             return

infrahub_sdk/ctl/generator.py

@@ -6,9 +6,8 @@ from typing import TYPE_CHECKING, Optional
 import typer
 from rich.console import Console
 
-from ..ctl import config
 from ..ctl.client import initialize_client
-from ..ctl.repository import get_repository_config
+from ..ctl.repository import find_repository_config_file, get_repository_config
 from ..ctl.utils import execute_graphql_query, init_logging, parse_cli_vars
 from ..exceptions import ModuleImportError
 from ..node import InfrahubNode
@@ -26,7 +25,7 @@ async def run(
     variables: Optional[list[str]] = None,
 ) -> None:
     init_logging(debug=debug)
-    repository_config = get_repository_config(Path(config.INFRAHUB_REPO_CONFIG_FILE))
+    repository_config = get_repository_config(find_repository_config_file())
 
     if list_available or not generator_name:
         list_generators(repository_config=repository_config)
@@ -65,6 +64,8 @@ async def run(
             branch=branch or "",
             params=variables_dict,
             convert_query_response=generator_config.convert_query_response,
+            execute_in_proposed_change=generator_config.execute_in_proposed_change,
+            execute_after_merge=generator_config.execute_after_merge,
             infrahub_node=InfrahubNode,
         )
         await generator._init_client.schema.all(branch=generator.branch_name)
@@ -94,6 +95,8 @@ async def run(
                 branch=branch or "",
                 params=params,
                 convert_query_response=generator_config.convert_query_response,
+                execute_in_proposed_change=generator_config.execute_in_proposed_change,
+                execute_after_merge=generator_config.execute_after_merge,
                 infrahub_node=InfrahubNode,
             )
             data = execute_graphql_query(

infrahub_sdk/ctl/graphql.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional
+
+import typer
+from ariadne_codegen.client_generators.package import PackageGenerator, get_package_generator
+from ariadne_codegen.exceptions import ParsingError
+from ariadne_codegen.plugins.explorer import get_plugins_types
+from ariadne_codegen.plugins.manager import PluginManager
+from ariadne_codegen.schema import (
+    filter_fragments_definitions,
+    filter_operations_definitions,
+    get_graphql_schema_from_path,
+)
+from ariadne_codegen.settings import ClientSettings, CommentsStrategy
+from ariadne_codegen.utils import ast_to_str
+from graphql import DefinitionNode, GraphQLSchema, NoUnusedFragmentsRule, parse, specified_rules, validate
+from rich.console import Console
+
+from ..async_typer import AsyncTyper
+from ..ctl.client import initialize_client
+from ..ctl.utils import catch_exception
+from ..graphql.utils import insert_fragments_inline, remove_fragment_import
+from .parameters import CONFIG_PARAM
+
+app = AsyncTyper()
+console = Console()
+
+ARIADNE_PLUGINS = [
+    "infrahub_sdk.graphql.plugin.PydanticBaseModelPlugin",
+    "infrahub_sdk.graphql.plugin.FutureAnnotationPlugin",
+    "infrahub_sdk.graphql.plugin.StandardTypeHintPlugin",
+]
+
+
+def find_gql_files(query_path: Path) -> list[Path]:
+    """
+    Find all files with .gql extension in the specified directory.
+
+    Args:
+        query_path: Path to the directory to search for .gql files
+
+    Returns:
+        List of Path objects for all .gql files found
+    """
+    if not query_path.exists():
+        raise FileNotFoundError(f"File or directory not found: {query_path}")
+
+    if not query_path.is_dir() and query_path.is_file():
+        return [query_path]
+
+    return list(query_path.glob("**/*.gql"))
+
+
+def get_graphql_query(queries_path: Path, schema: GraphQLSchema) -> tuple[DefinitionNode, ...]:
+    """Get GraphQL queries definitions from a single GraphQL file."""
+
+    if not queries_path.exists():
+        raise FileNotFoundError(f"File not found: {queries_path}")
+    if not queries_path.is_file():
+        raise ValueError(f"{queries_path} is not a file")
+
+    queries_str = queries_path.read_text(encoding="utf-8")
+    queries_ast = parse(queries_str)
+    validation_errors = validate(
+        schema=schema,
+        document_ast=queries_ast,
+        rules=[r for r in specified_rules if r is not NoUnusedFragmentsRule],
+    )
+    if validation_errors:
+        raise ValueError("\n\n".join(error.message for error in validation_errors))
+    return queries_ast.definitions
+
+
+def generate_result_types(directory: Path, package: PackageGenerator, fragment: ast.Module) -> None:
+    for file_name, module in package._result_types_files.items():
+        file_path = directory / file_name
+
+        insert_fragments_inline(module, fragment)
+        remove_fragment_import(module)
+
+        code = package._add_comments_to_code(ast_to_str(module), package.queries_source)
+        if package.plugin_manager:
+            code = package.plugin_manager.generate_result_types_code(code)
+        file_path.write_text(code)
+        package._generated_files.append(file_path.name)
+
+
+@app.callback()
+def callback() -> None:
+    """
+    Various GraphQL related commands.
+    """
+
+
+@app.command()
+@catch_exception(console=console)
+async def export_schema(
+    destination: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Export the GraphQL schema to a file."""
+
+    client = initialize_client()
+    schema_text = await client.schema.get_graphql_schema()
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.write_text(schema_text)
+    console.print(f"[green]Schema exported to {destination}")
+
+
+@app.command()
+@catch_exception(console=console)
+async def generate_return_types(
+    query: Optional[Path] = typer.Argument(
+        None, help="Location of the GraphQL query file(s). Defaults to current directory if not specified."
+    ),
+    schema: Path = typer.Option("schema.graphql", help="Path to the GraphQL schema file."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Create Pydantic Models for GraphQL query return types"""
+
+    query = Path.cwd() if query is None else query
+
+    # Load the GraphQL schema
+    if not schema.exists():
+        raise FileNotFoundError(f"GraphQL Schema file not found: {schema}")
+    graphql_schema = get_graphql_schema_from_path(schema_path=str(schema))
+
+    # Initialize the plugin manager
+    plugin_manager = PluginManager(
+        schema=graphql_schema,
+        plugins_types=get_plugins_types(plugins_strs=ARIADNE_PLUGINS),
+    )
+
+    # Find the GraphQL files and organize them by directory
+    gql_files = find_gql_files(query)
+    gql_per_directory: dict[Path, list[Path]] = defaultdict(list)
+    for gql_file in gql_files:
+        gql_per_directory[gql_file.parent].append(gql_file)
+
+    # Generate the Pydantic Models for the GraphQL queries
+    for directory, gql_files in gql_per_directory.items():
+        for gql_file in gql_files:
+            try:
+                definitions = get_graphql_query(queries_path=gql_file, schema=graphql_schema)
+            except ValueError as exc:
+                console.print(f"[red]Error generating result types for {gql_file}: {exc}")
+                continue
+            queries = filter_operations_definitions(definitions)
+            fragments = filter_fragments_definitions(definitions)
+
+            package_generator = get_package_generator(
+                schema=graphql_schema,
+                fragments=fragments,
+                settings=ClientSettings(
+                    schema_path=str(schema),
+                    target_package_name=directory.name,
+                    queries_path=str(directory),
+                    include_comments=CommentsStrategy.NONE,
+                ),
+                plugin_manager=plugin_manager,
+            )
+
+            parsing_failed = False
+            try:
+                for query_operation in queries:
+                    package_generator.add_operation(query_operation)
+            except ParsingError as exc:
+                console.print(f"[red]Unable to process {gql_file.name}: {exc}")
+                parsing_failed = True
+
+            if parsing_failed:
+                continue
+
+            module_fragment = package_generator.fragments_generator.generate()
+
+            generate_result_types(directory=directory, package=package_generator, fragment=module_fragment)
+
+            for file_name in package_generator._result_types_files.keys():
+                console.print(f"[green]Generated {file_name} in {directory}")

infrahub_sdk/ctl/repository.py

@@ -24,11 +24,49 @@ app = AsyncTyper()
 console = Console()
 
 
+def find_repository_config_file(base_path: Path | None = None) -> Path:
+    """Find the repository config file, checking for both .yml and .yaml extensions.
+
+    Args:
+        base_path: Base directory to search in. If None, uses current directory.
+
+    Returns:
+        Path to the config file.
+
+    Raises:
+        FileNotFoundError: If neither .infrahub.yml nor .infrahub.yaml exists.
+    """
+    if base_path is None:
+        base_path = Path()
+
+    yml_path = base_path / ".infrahub.yml"
+    yaml_path = base_path / ".infrahub.yaml"
+
+    # Prefer .yml if both exist
+    if yml_path.exists():
+        return yml_path
+    if yaml_path.exists():
+        return yaml_path
+    # For backward compatibility, return .yml path for error messages
+    return yml_path
+
+
 def get_repository_config(repo_config_file: Path) -> InfrahubRepositoryConfig:
+    # If the file doesn't exist, try to find it with alternate extension
+    if not repo_config_file.exists():
+        if repo_config_file.name == ".infrahub.yml":
+            alt_path = repo_config_file.parent / ".infrahub.yaml"
+            if alt_path.exists():
+                repo_config_file = alt_path
+        elif repo_config_file.name == ".infrahub.yaml":
+            alt_path = repo_config_file.parent / ".infrahub.yml"
+            if alt_path.exists():
+                repo_config_file = alt_path
+
     try:
         config_file_data = load_repository_config_file(repo_config_file)
     except FileNotFoundError as exc:
-        console.print(f"[red]File not found {exc}")
+        console.print(f"[red]File not found {exc} (also checked for .infrahub.yml and .infrahub.yaml)")
         raise typer.Exit(1) from exc
     except FileNotValidError as exc:
         console.print(f"[red]{exc.message}")

infrahub_sdk/ctl/schema.py

@@ -14,6 +14,7 @@ from ..async_typer import AsyncTyper
 from ..ctl.client import initialize_client
 from ..ctl.utils import catch_exception, init_logging
 from ..queries import SCHEMA_HASH_SYNC_STATUS
+from ..schema import SchemaWarning
 from ..yaml import SchemaFile
 from .parameters import CONFIG_PARAM
 from .utils import load_yamlfile_from_disk_and_exit
@@ -73,14 +74,29 @@ def display_schema_load_errors(response: dict[str, Any], schemas_data: list[Sche
             loc_type = loc_path[-1]
             input_str = error.get("input", None)
             error_message = f"{loc_type} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
         elif len(loc_path) > 6:
             loc_type = loc_path[5]
-            input_label = node[loc_type][loc_path[6]].get("name", None)
+            error_data = node[loc_type]
+            attribute = loc_path[6]
+
+            if isinstance(attribute, str):
+                input_label = None
+                for data in error_data:
+                    if data.get(attribute) is not None:
+                        input_label = data.get("name", None)
+                        break
+            else:
+                input_label = error_data[attribute].get("name", None)
+
             input_str = error.get("input", None)
             error_message = f"{loc_type[:-1].title()}: {input_label} ({input_str}) | {error['msg']} ({error['type']})"
-            console.print(f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}")
+            console.print(
+                f"  Node: {node.get('namespace', None)}{node.get('name', None)} | {error_message}", markup=False
+            )
 
 
 def handle_non_detail_errors(response: dict[str, Any]) -> None:
@@ -137,6 +153,8 @@ async def load(
 
     console.print(f"[green] {len(schemas_data)} {schema_definition} processed in {loading_time:.3f} seconds.")
 
+    _display_schema_warnings(console=console, warnings=response.warnings)
+
     if response.schema_updated and wait:
         waited = 0
         continue_waiting = True
@@ -172,12 +190,24 @@ async def check(
 
     success, response = await client.schema.check(schemas=[item.payload for item in schemas_data], branch=branch)
 
-    if not success:
+    if not success or not response:
         display_schema_load_errors(response=response or {}, schemas_data=schemas_data)
+        return
+
+    for schema_file in schemas_data:
+        console.print(f"[green] schema '{schema_file.location}' is Valid!")
+
+    warnings = response.pop("warnings", [])
+    schema_warnings = [SchemaWarning.model_validate(warning) for warning in warnings]
+    _display_schema_warnings(console=console, warnings=schema_warnings)
+    if response == {"diff": {"added": {}, "changed": {}, "removed": {}}}:
+        print("No diff")
     else:
-        for schema_file in schemas_data:
-            console.print(f"[green] schema '{schema_file.location}' is Valid!")
-        if response == {"diff": {"added": {}, "changed": {}, "removed": {}}}:
-            print("No diff")
-        else:
-            print(yaml.safe_dump(data=response, indent=4))
+        print(yaml.safe_dump(data=response, indent=4))
+
+
+def _display_schema_warnings(console: Console, warnings: list[SchemaWarning]) -> None:
+    for warning in warnings:
+        console.print(
+            f"[yellow] {warning.type.value}: {warning.message} [{', '.join([kind.display for kind in warning.kinds])}]"
+        )