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

infrahub/api/dependencies.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, AsyncIterator, Optional
+from typing import TYPE_CHECKING, AsyncIterator
 
 from fastapi import Depends, Query, Request
 from fastapi.security import APIKeyHeader, HTTPAuthorizationCredentials, HTTPBearer
@@ -25,7 +25,7 @@ jwt_scheme = HTTPBearer(auto_error=False)
 api_key_scheme = APIKeyHeader(name="X-INFRAHUB-KEY", auto_error=False)
 
 
-async def cookie_auth_scheme(request: Request) -> Optional[str]:
+async def cookie_auth_scheme(request: Request) -> str | None:
     return request.cookies.get("access_token")  # Replace with the actual name of your JWT cookie
 
 
@@ -62,7 +62,7 @@ async def get_access_token(
 async def get_refresh_token(
     request: Request,
     db: InfrahubDatabase = Depends(get_db),
-    jwt_header: Optional[HTTPAuthorizationCredentials] = Depends(jwt_scheme),
+    jwt_header: HTTPAuthorizationCredentials | None = Depends(jwt_scheme),
 ) -> RefreshTokenData:
     token = None
 
@@ -83,8 +83,8 @@ async def get_refresh_token(
 
 async def get_branch_params(
     db: InfrahubDatabase = Depends(get_db),
-    branch_name: Optional[str] = Query(None, alias="branch", description="Name of the branch to use for the query"),
-    at: Optional[str] = Query(None, description="Time to use for the query, in absolute or relative format"),
+    branch_name: str | None = Query(None, alias="branch", description="Name of the branch to use for the query"),
+    at: str | None = Query(None, description="Time to use for the query, in absolute or relative format"),
 ) -> BranchParams:
     branch = await registry.get_branch(db=db, branch=branch_name)
 
@@ -93,7 +93,7 @@ async def get_branch_params(
 
 async def get_branch_dep(
     db: InfrahubDatabase = Depends(get_db),
-    branch_name: Optional[str] = Query(None, alias="branch", description="Name of the branch to use for the query"),
+    branch_name: str | None = Query(None, alias="branch", description="Name of the branch to use for the query"),
 ) -> Branch:
     return await registry.get_branch(db=db, branch=branch_name)
 

infrahub/api/diff/validation_models.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 
@@ -9,13 +9,13 @@ from infrahub.core.timestamp import Timestamp
 class DiffQueryValidated(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     branch: Branch
-    time_from: Optional[str] = None
-    time_to: Optional[str] = None
+    time_from: str | None = None
+    time_to: str | None = None
     branch_only: bool
 
     @field_validator("time_from", "time_to", mode="before")
     @classmethod
-    def validate_time(cls, value: Optional[str]) -> Optional[str]:
+    def validate_time(cls, value: str | None) -> str | None:
         if not value:
             return None
         Timestamp(value)
@@ -24,12 +24,12 @@ class DiffQueryValidated(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def validate_time_from_if_required(cls, values: dict[str, Any]) -> dict[str, Any]:
-        branch: Optional[Branch] = values.get("branch")
-        time_from: Optional[Timestamp] = values.get("time_from")
+        branch: Branch | None = values.get("branch")
+        time_from: Timestamp | None = values.get("time_from")
         if getattr(branch, "is_default", False) and not time_from:
             branch_name = getattr(branch, "name", "")
             raise ValueError(f"time_from is mandatory when diffing on the default branch `{branch_name}`.")
-        time_to: Optional[Timestamp] = values.get("time_to")
+        time_to: Timestamp | None = values.get("time_to")
         if time_to and time_from and time_to < time_from:
             raise ValueError("time_from and time_to are not a valid time range")
         return values

infrahub/api/schema.py

@@ -68,7 +68,7 @@ class APISchemaMixin:
     @classmethod
     def set_kind(cls, values: Any) -> Any:
         if isinstance(values, dict):
-            values["kind"] = f'{values["namespace"]}{values["name"]}'
+            values["kind"] = f"{values['namespace']}{values['name']}"
         return values
 
 

infrahub/artifacts/models.py

@@ -1,7 +1,7 @@
-from typing import Optional
-
 from pydantic import BaseModel, Field
 
+from infrahub.context import InfrahubContext
+
 
 class CheckArtifactCreate(BaseModel):
     """Runs a check to verify the creation of an artifact."""
@@ -17,9 +17,11 @@ class CheckArtifactCreate(BaseModel):
     repository_kind: str = Field(..., description="The kind of the Repository")
     branch_name: str = Field(..., description="The branch where the check is run")
     target_id: str = Field(..., description="The ID of the target object for this artifact")
+    target_kind: str = Field(..., description="The kind of the target object for this artifact")
     target_name: str = Field(..., description="Name of the artifact target")
-    artifact_id: Optional[str] = Field(default=None, description="The id of the artifact if it previously existed")
+    artifact_id: str | None = Field(default=None, description="The id of the artifact if it previously existed")
     query: str = Field(..., description="The name of the query to use when collecting data")
     timeout: int = Field(..., description="Timeout for requests used to generate this artifact")
     variables: dict = Field(..., description="Input variables when generating the artifact")
     validator_id: str = Field(..., description="The ID of the validator")
+    context: InfrahubContext = Field(..., description="The context of the task")

infrahub/artifacts/tasks.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 from prefect import flow
 
 from infrahub.artifacts.models import CheckArtifactCreate
@@ -32,10 +30,10 @@ async def create(model: CheckArtifactCreate, service: InfrahubServices) -> Valid
             service=service,
         )
 
-    artifact = await define_artifact(model=model, service=service)
+    artifact, artifact_created = await define_artifact(model=model, service=service)
 
     severity = "info"
-    artifact_result: dict[str, Union[str, bool, None]] = {
+    artifact_result: dict[str, str | bool | None] = {
         "changed": None,
         "checksum": None,
         "artifact_id": None,
@@ -44,7 +42,7 @@ async def create(model: CheckArtifactCreate, service: InfrahubServices) -> Valid
     check_message = "Failed to render artifact"
 
     try:
-        result = await repo.render_artifact(artifact=artifact, message=model)
+        result = await repo.render_artifact(artifact=artifact, artifact_created=artifact_created, message=model)
         artifact_result["changed"] = result.changed
         artifact_result["checksum"] = result.checksum
         artifact_result["artifact_id"] = result.artifact_id

infrahub/cli/__init__.py

@@ -1,18 +1,21 @@
 from asyncio import run as aiorun
 
 import typer
+from infrahub_sdk.async_typer import AsyncTyper
 
 from infrahub import config
-from infrahub.cli.context import CliContext
-from infrahub.cli.db import app as db_app
-from infrahub.cli.events import app as events_app
-from infrahub.cli.git_agent import app as git_app
-from infrahub.cli.server import app as server_app
-from infrahub.cli.tasks import app as tasks_app
 from infrahub.core.initialization import initialization
 from infrahub.database import InfrahubDatabase, get_db
 
-app = typer.Typer(name="Infrahub CLI", pretty_exceptions_enable=False)
+from .context import CliContext
+from .db import app as db_app
+from .events import app as events_app
+from .git_agent import app as git_app
+from .server import app as server_app
+from .tasks import app as tasks_app
+from .upgrade import upgrade_cmd
+
+app = AsyncTyper(name="Infrahub CLI", pretty_exceptions_enable=False)
 
 
 @app.callback()
@@ -22,10 +25,11 @@ def common(ctx: typer.Context) -> None:
 
 
 app.add_typer(server_app, name="server")
-app.add_typer(git_app, name="git-agent")
+app.add_typer(git_app, name="git-agent", hidden=True)
 app.add_typer(db_app, name="db")
-app.add_typer(events_app, name="events", help="Interact with the events system.")
+app.add_typer(events_app, name="events", help="Interact with the events system.", hidden=True)
 app.add_typer(tasks_app, name="tasks", hidden=True)
+app.command(name="upgrade")(upgrade_cmd)
 
 
 async def _init_shell(config_file: str) -> None:

infrahub/cli/constants.py

@@ -0,0 +1,3 @@
+ERROR_BADGE = "[bold red]ERROR[/bold red]"
+SUCCESS_BADGE = "[green]SUCCESS[/green]"
+FAILED_BADGE = "[bold red]FAILED[/bold red]"

infrahub/cli/db.py

@@ -4,7 +4,7 @@ import importlib
 import logging
 import os
 from enum import Enum
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import typer
 from infrahub_sdk.async_typer import AsyncTyper
@@ -16,23 +16,16 @@ from rich.table import Table
 
 from infrahub import config
 from infrahub.core import registry
-from infrahub.core.constants import InfrahubKind
 from infrahub.core.graph import GRAPH_VERSION
 from infrahub.core.graph.constraints import ConstraintManagerBase, ConstraintManagerMemgraph, ConstraintManagerNeo4j
 from infrahub.core.graph.index import node_indexes, rel_indexes
 from infrahub.core.graph.schema import GRAPH_SCHEMA
 from infrahub.core.initialization import (
-    create_anonymous_role,
-    create_default_menu,
-    create_default_roles,
-    create_super_administrator_role,
-    create_super_administrators_group,
     first_time_initialization,
     get_root_node,
     initialization,
     initialize_registry,
 )
-from infrahub.core.manager import NodeManager
 from infrahub.core.migrations.graph import get_graph_migrations
 from infrahub.core.migrations.schema.models import SchemaApplyMigrationData
 from infrahub.core.migrations.schema.tasks import schema_apply_migrations
@@ -48,6 +41,8 @@ from infrahub.services import InfrahubServices
 from infrahub.services.adapters.message_bus.local import BusSimulator
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 
+from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
+
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
     from infrahub.database import InfrahubDatabase
@@ -121,6 +116,7 @@ async def load_test_data(
 
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
+
     async with dbdriver.start_session() as db:
         await initialization(db=db)
 
@@ -136,8 +132,8 @@ async def load_test_data(
     await dbdriver.close()
 
 
-@app.command()
-async def migrate(
+@app.command(name="migrate")
+async def migrate_cmd(
     ctx: typer.Context,
     check: bool = typer.Option(False, help="Check the state of the database without applying the migrations."),
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
@@ -147,53 +143,18 @@ async def migrate(
     logging.getLogger("neo4j").setLevel(logging.ERROR)
     logging.getLogger("prefect").setLevel(logging.ERROR)
 
-    log = get_logger()
-
     config.load_and_exit(config_file_name=config_file)
 
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
-    async with dbdriver.start_session() as db:
-        rprint("Checking current state of the Database")
 
-        await initialize_registry(db=db)
-        root_node = await get_root_node(db=db)
-        migrations = await get_graph_migrations(root=root_node)
-
-        if not migrations:
-            rprint(f"Database up-to-date (v{root_node.graph_version}), no migration to execute.")
-        else:
-            rprint(
-                f"Database needs to be updated (v{root_node.graph_version} -> v{GRAPH_VERSION}), {len(migrations)} migrations pending"
-            )
-
-        if migrations and not check:
-            for migration in migrations:
-                log.debug(f"Execute Migration: {migration.name}")
-                execution_result = await migration.execute(db=db)
-                validation_result = None
-
-                if execution_result.success:
-                    validation_result = await migration.validate_migration(db=db)
-                    if validation_result.success:
-                        rprint(f"Migration: {migration.name} [green]SUCCESS[/green]")
-                        root_node.graph_version = migration.minimum_version + 1
-                        await root_node.save(db=db)
-
-                if not execution_result.success or validation_result and not validation_result.success:
-                    rprint(f"Migration: {migration.name} [bold red]FAILED[/bold red]")
-                    for error in execution_result.errors:
-                        rprint(f"  {error}")
-                    if validation_result and not validation_result.success:
-                        for error in validation_result.errors:
-                            rprint(f"  {error}")
-                    break
+    await migrate_database(db=dbdriver, initialize=True, check=check)
 
     await dbdriver.close()
 
 
-@app.command()
-async def update_core_schema(
+@app.command(name="update-core-schema")
+async def update_core_schema_cmd(
     ctx: typer.Context,
     debug: bool = typer.Option(False, help="Enable advanced logging and troubleshooting"),
     config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
@@ -209,116 +170,14 @@ async def update_core_schema(
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
 
-    error_badge = "[bold red]ERROR[/bold red]"
+    service = await InfrahubServices.new(
+        database=dbdriver, message_bus=BusSimulator(), workflow=WorkflowLocalExecution()
+    )
 
-    async with dbdriver.start_session() as db:
-        with prefect_test_harness():
-            # ----------------------------------------------------------
-            # Initialize Schema and Registry
-            # ----------------------------------------------------------
-            service = await InfrahubServices.new(
-                database=db, message_bus=BusSimulator(), workflow=WorkflowLocalExecution()
-            )
-            await initialize_registry(db=db)
-
-            default_branch = registry.get_branch_from_registry(branch=registry.default_branch)
-
-            registry.schema = SchemaManager()
-            schema = SchemaRoot(**internal_schema)
-            registry.schema.register_schema(schema=schema)
-
-            # ----------------------------------------------------------
-            # Load Current Schema from the database
-            # ----------------------------------------------------------
-            schema_default_branch = await registry.schema.load_schema_from_db(db=db, branch=default_branch)
-            registry.schema.set_schema_branch(name=default_branch.name, schema=schema_default_branch)
-            branch_schema = registry.schema.get_schema_branch(name=registry.default_branch)
-
-            candidate_schema = branch_schema.duplicate()
-            candidate_schema.load_schema(schema=SchemaRoot(**internal_schema))
-            candidate_schema.load_schema(schema=SchemaRoot(**core_models))
-            candidate_schema.load_schema(schema=SchemaRoot(**deprecated_models))
-            candidate_schema.process()
-
-            schema_diff = branch_schema.diff(other=candidate_schema)
-            branch_schema.validate_node_deletions(diff=schema_diff)
-            result = branch_schema.validate_update(
-                other=candidate_schema, diff=schema_diff, enforce_update_support=False
-            )
-            if result.errors:
-                rprint(f"{error_badge} | Unable to update the schema, due to failed validations")
-                for error in result.errors:
-                    rprint(error.to_string())
-                raise typer.Exit(1)
-
-            if not result.diff.all:
-                await create_defaults(db=db)
-                rprint("Core Schema Up to date, nothing to update")
-                raise typer.Exit(0)
-
-            rprint("Core Schema has diff, will need to be updated")
-            if debug:
-                result.diff.print()
-
-            # ----------------------------------------------------------
-            # Validate if the new schema is valid with the content of the database
-            # ----------------------------------------------------------
-            validate_migration_data = SchemaValidateMigrationData(
-                branch=default_branch,
-                schema_branch=candidate_schema,
-                constraints=result.constraints,
-            )
-            responses = await schema_validate_migrations(message=validate_migration_data, service=service)
-            error_messages = [violation.message for response in responses for violation in response.violations]
-            if error_messages:
-                rprint(f"{error_badge} | Unable to update the schema, due to failed validations")
-                for message in error_messages:
-                    rprint(message)
-                raise typer.Exit(1)
-
-            # ----------------------------------------------------------
-            # Update the schema
-            # ----------------------------------------------------------
-            origin_schema = branch_schema.duplicate()
-
-            # Update the internal schema
-            schema_default_branch.load_schema(schema=SchemaRoot(**internal_schema))
-            schema_default_branch.process()
-            registry.schema.set_schema_branch(name=default_branch.name, schema=schema_default_branch)
-
-            async with db.start_transaction() as dbt:
-                await registry.schema.update_schema_branch(
-                    schema=candidate_schema,
-                    db=dbt,
-                    branch=default_branch.name,
-                    diff=result.diff,
-                    limit=result.diff.all,
-                    update_db=True,
-                )
-                default_branch.update_schema_hash()
-                rprint("The Core Schema has been updated")
-                if debug:
-                    rprint(f"New schema hash: {default_branch.active_schema_hash.main}")
-                await default_branch.save(db=dbt)
-
-            # ----------------------------------------------------------
-            # Run the migrations
-            # ----------------------------------------------------------
-            apply_migration_data = SchemaApplyMigrationData(
-                branch=default_branch,
-                new_schema=candidate_schema,
-                previous_schema=origin_schema,
-                migrations=result.migrations,
-            )
-            migration_error_msgs = await schema_apply_migrations(message=apply_migration_data, service=service)
-
-            if migration_error_msgs:
-                rprint(f"{error_badge} | Some error(s) happened while running the schema migrations")
-                for message in migration_error_msgs:
-                    rprint(message)
-                raise typer.Exit(1)
-
-            await create_defaults(db=db)
+    with prefect_test_harness():
+        await update_core_schema(db=dbdriver, service=service, initialize=True, debug=debug)
+
+    await dbdriver.close()
 
 
 @app.command()
@@ -333,7 +192,7 @@ async def constraint(
     context: CliContext = ctx.obj
     dbdriver = await context.init_db(retry=1)
 
-    manager: Optional[ConstraintManagerBase] = None
+    manager: ConstraintManagerBase | None = None
     if dbdriver.db_type == DatabaseType.NEO4J:
         manager = ConstraintManagerNeo4j.from_graph_schema(db=dbdriver, schema=GRAPH_SCHEMA)
     elif dbdriver.db_type == DatabaseType.MEMGRAPH:
@@ -405,35 +264,158 @@ async def index(
     await dbdriver.close()
 
 
-async def create_defaults(db: InfrahubDatabase) -> None:
-    """Create and assign default objects."""
-    existing_permissions = await NodeManager.query(
-        schema=InfrahubKind.OBJECTPERMISSION,
-        db=db,
-        limit=1,
-    )
-    if not existing_permissions:
-        await setup_permissions(db=db)
+async def migrate_database(db: InfrahubDatabase, initialize: bool = False, check: bool = False) -> None:
+    """Apply the latest migrations to the database, this function will print the status directly in the console.
+
+    This function is expected to run on an empty
+
+    Args:
+        db: The database object.
+        check: If True, the function will only check the status of the database and not apply the migrations. Defaults to False.
+    """
+    rprint("Checking current state of the Database")
+
+    if initialize:
+        await initialize_registry(db=db)
+
+    root_node = await get_root_node(db=db)
+    migrations = await get_graph_migrations(root=root_node)
+
+    if not migrations:
+        rprint(f"Database up-to-date (v{root_node.graph_version}), no migration to execute.")
+        return
 
-    existing_menu_items = await NodeManager.query(
-        schema=InfrahubKind.MENUITEM,
-        db=db,
-        limit=1,
+    rprint(
+        f"Database needs to be updated (v{root_node.graph_version} -> v{GRAPH_VERSION}), {len(migrations)} migrations pending"
     )
-    if not existing_menu_items:
-        await create_default_menu(db=db)
+
+    if check:
+        return
+
+    for migration in migrations:
+        execution_result = await migration.execute(db=db)
+        validation_result = None
+
+        if execution_result.success:
+            validation_result = await migration.validate_migration(db=db)
+            if validation_result.success:
+                rprint(f"Migration: {migration.name} {SUCCESS_BADGE}")
+                root_node.graph_version = migration.minimum_version + 1
+                await root_node.save(db=db)
+
+        if not execution_result.success or validation_result and not validation_result.success:
+            rprint(f"Migration: {migration.name} {FAILED_BADGE}")
+            for error in execution_result.errors:
+                rprint(f"  {error}")
+            if validation_result and not validation_result.success:
+                for error in validation_result.errors:
+                    rprint(f"  {error}")
+            break
+
+
+async def initialize_internal_schema() -> None:
+    registry.schema = SchemaManager()
+    schema = SchemaRoot(**internal_schema)
+    registry.schema.register_schema(schema=schema)
 
 
-async def setup_permissions(db: InfrahubDatabase) -> None:
-    existing_accounts = await NodeManager.query(
-        schema=InfrahubKind.ACCOUNT,
-        db=db,
-        limit=1,
+async def update_core_schema(
+    db: InfrahubDatabase, service: InfrahubServices, initialize: bool = True, debug: bool = False
+) -> None:
+    """Update the core schema of Infrahub to the latest version"""
+    # ----------------------------------------------------------
+    # Initialize Schema and Registry
+    # ----------------------------------------------------------
+    if initialize:
+        await initialize_registry(db=db)
+        await initialize_internal_schema()
+
+    default_branch = registry.get_branch_from_registry(branch=registry.default_branch)
+
+    # ----------------------------------------------------------
+    # Load Current Schema from the database
+    # ----------------------------------------------------------
+    schema_default_branch = await registry.schema.load_schema_from_db(db=db, branch=default_branch)
+    registry.schema.set_schema_branch(name=default_branch.name, schema=schema_default_branch)
+    branch_schema = registry.schema.get_schema_branch(name=registry.default_branch)
+
+    candidate_schema = branch_schema.duplicate()
+    candidate_schema.load_schema(schema=SchemaRoot(**internal_schema))
+    candidate_schema.load_schema(schema=SchemaRoot(**core_models))
+    candidate_schema.load_schema(schema=SchemaRoot(**deprecated_models))
+    candidate_schema.process()
+
+    schema_diff = branch_schema.diff(other=candidate_schema)
+    branch_schema.validate_node_deletions(diff=schema_diff)
+    result = branch_schema.validate_update(other=candidate_schema, diff=schema_diff, enforce_update_support=False)
+    if result.errors:
+        rprint(f"{ERROR_BADGE} | Unable to update the schema, due to failed validations")
+        for error in result.errors:
+            rprint(error.to_string())
+        raise typer.Exit(1)
+
+    if not result.diff.all:
+        rprint("Core Schema Up to date, nothing to update")
+        return
+
+    rprint("Core Schema has diff, will need to be updated")
+    if debug:
+        result.diff.print()
+
+    # ----------------------------------------------------------
+    # Validate if the new schema is valid with the content of the database
+    # ----------------------------------------------------------
+    validate_migration_data = SchemaValidateMigrationData(
+        branch=default_branch,
+        schema_branch=candidate_schema,
+        constraints=result.constraints,
     )
-    administrator_role = await create_super_administrator_role(db=db)
-    await create_super_administrators_group(db=db, role=administrator_role, admin_accounts=existing_accounts)
+    responses = await schema_validate_migrations(message=validate_migration_data, service=service)
+    error_messages = [violation.message for response in responses for violation in response.violations]
+    if error_messages:
+        rprint(f"{ERROR_BADGE} | Unable to update the schema, due to failed validations")
+        for message in error_messages:
+            rprint(message)
+        raise typer.Exit(1)
 
-    await create_default_roles(db=db)
+    # ----------------------------------------------------------
+    # Update the schema
+    # ----------------------------------------------------------
+    origin_schema = branch_schema.duplicate()
+
+    # Update the internal schema
+    schema_default_branch.load_schema(schema=SchemaRoot(**internal_schema))
+    schema_default_branch.process()
+    registry.schema.set_schema_branch(name=default_branch.name, schema=schema_default_branch)
+
+    async with db.start_transaction() as dbt:
+        await registry.schema.update_schema_branch(
+            schema=candidate_schema,
+            db=dbt,
+            branch=default_branch.name,
+            diff=result.diff,
+            limit=result.diff.all,
+            update_db=True,
+        )
+        default_branch.update_schema_hash()
+        rprint("The Core Schema has been updated")
+        if debug:
+            rprint(f"New schema hash: {default_branch.active_schema_hash.main}")
+        await default_branch.save(db=dbt)
+
+    # ----------------------------------------------------------
+    # Run the migrations
+    # ----------------------------------------------------------
+    apply_migration_data = SchemaApplyMigrationData(
+        branch=default_branch,
+        new_schema=candidate_schema,
+        previous_schema=origin_schema,
+        migrations=result.migrations,
+    )
+    migration_error_msgs = await schema_apply_migrations(message=apply_migration_data, service=service)
 
-    if config.SETTINGS.main.allow_anonymous_access:
-        await create_anonymous_role(db=db)
+    if migration_error_msgs:
+        rprint(f"{ERROR_BADGE} | Some error(s) happened while running the schema migrations")
+        for message in migration_error_msgs:
+            rprint(message)
+        raise typer.Exit(1)