diff --git a/flama/ddd/repositories/__init__.py b/flama/ddd/repositories/__init__.py
index 11881a74..223b61f8 100644
--- a/flama/ddd/repositories/__init__.py
+++ b/flama/ddd/repositories/__init__.py
@@ -1,3 +1,2 @@
 from flama.ddd.repositories.base import *  # noqa
 from flama.ddd.repositories.http import *  # noqa
-from flama.ddd.repositories.sqlalchemy import *  # noqa
diff --git a/flama/ddd/repositories/sqlalchemy.py b/flama/ddd/repositories/sqlalchemy.py
index 5968a84d..424a2416 100644
--- a/flama/ddd/repositories/sqlalchemy.py
+++ b/flama/ddd/repositories/sqlalchemy.py
@@ -7,30 +7,20 @@
 try:
     import sqlalchemy
     import sqlalchemy.exc as sqlalchemy_exceptions
+    from sqlalchemy.ext.asyncio import AsyncConnection
 except Exception:  # pragma: no cover
-    sqlalchemy = None
-    sqlalchemy_exceptions = None
+    raise exceptions.DependencyNotInstalled(
+        dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy, dependant=__name__
+    )
 
 
-if t.TYPE_CHECKING:
-    try:
-        from sqlalchemy.ext.asyncio import AsyncConnection
-    except Exception:  # pragma: no cover
-        ...
-
 __all__ = ["SQLAlchemyRepository", "SQLAlchemyTableManager", "SQLAlchemyTableRepository"]
 
 
 class SQLAlchemyRepository(AbstractRepository):
     """Base class for SQLAlchemy repositories. It provides a connection to the database."""
 
-    def __init__(self, connection: "AsyncConnection", *args, **kwargs):
-        if sqlalchemy is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
+    def __init__(self, connection: AsyncConnection, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._connection = connection
 
@@ -39,13 +29,7 @@ def __eq__(self, other):
 
 
 class SQLAlchemyTableManager:
-    def __init__(self, table: sqlalchemy.Table, connection: "AsyncConnection"):  # type: ignore
-        if sqlalchemy is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
+    def __init__(self, table: sqlalchemy.Table, connection: AsyncConnection):  # type: ignore
         self._connection = connection
         self.table = table
 
@@ -66,12 +50,6 @@ async def create(self, *data: dict[str, t.Any]) -> list[dict[str, t.Any]]:
         :return: The created elements.
         :raises IntegrityError: If the element already exists or cannot be inserted.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         try:
             result = await self._connection.execute(sqlalchemy.insert(self.table).values(data).returning(self.table))
         except sqlalchemy_exceptions.IntegrityError as e:
@@ -94,12 +72,6 @@ async def retrieve(self, *clauses, **filters) -> dict[str, t.Any]:
         :raises NotFoundError: If the element does not exist.
         :raises MultipleRecordsError: If more than one element is found.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         query = self._filter_query(sqlalchemy.select(self.table), *clauses, **filters)
 
         try:
@@ -121,12 +93,6 @@ async def update(self, data: dict[str, t.Any], *clauses, **filters) -> list[dict
         :return: The updated elements.
         :raises IntegrityError: If the elements cannot be updated.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         query = (
             self._filter_query(sqlalchemy.update(self.table), *clauses, **filters).values(**data).returning(self.table)
         )
@@ -152,12 +118,6 @@ async def delete(self, *clauses, **filters) -> None:
         :raises NotFoundError: If the element does not exist.
         :raises MultipleRecordsError: If more than one element is found.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         await self.retrieve(*clauses, **filters)
 
         query = self._filter_query(sqlalchemy.delete(self.table), *clauses, **filters)
@@ -185,12 +145,6 @@ async def list(
         :param filters: Filters to filter the elements.
         :return: Async iterable of the elements.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         query = self._filter_query(sqlalchemy.select(self.table), *clauses, **filters)
 
         if order_by:
@@ -219,12 +173,6 @@ async def drop(self, *clauses, **filters) -> int:
         :param filters: Filters to filter the elements.
         :return: The number of elements dropped.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         query = self._filter_query(sqlalchemy.delete(self.table), *clauses, **filters)
 
         result = await self._connection.execute(query)
@@ -248,12 +196,6 @@ def _filter_query(self, query, *clauses, **filters):
         :param filters: Filters to filter the elements.
         :return: The filtered query.
         """
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         where_clauses = tuple(clauses) + tuple(self.table.c[k] == v for k, v in filters.items())
 
         if where_clauses:
@@ -265,13 +207,7 @@ def _filter_query(self, query, *clauses, **filters):
 class SQLAlchemyTableRepository(SQLAlchemyRepository):
     _table: t.ClassVar[sqlalchemy.Table]  # type: ignore
 
-    def __init__(self, connection: "AsyncConnection", *args, **kwargs):
-        if sqlalchemy is None or sqlalchemy_exceptions is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
+    def __init__(self, connection: AsyncConnection, *args, **kwargs):
         super().__init__(connection, *args, **kwargs)
         self._table_manager = SQLAlchemyTableManager(self._table, connection)
 
diff --git a/flama/ddd/workers/__init__.py b/flama/ddd/workers/__init__.py
index 9e441706..2c7b81d2 100644
--- a/flama/ddd/workers/__init__.py
+++ b/flama/ddd/workers/__init__.py
@@ -1,3 +1,2 @@
 from flama.ddd.workers.base import *  # noqa
 from flama.ddd.workers.http import *  # noqa
-from flama.ddd.workers.sqlalchemy import *  # noqa
diff --git a/flama/ddd/workers/sqlalchemy.py b/flama/ddd/workers/sqlalchemy.py
index 33929243..bd4cd2d4 100644
--- a/flama/ddd/workers/sqlalchemy.py
+++ b/flama/ddd/workers/sqlalchemy.py
@@ -1,10 +1,15 @@
 import logging
-import typing as t
 
+from flama import exceptions
 from flama.ddd.workers.base import AbstractWorker
 
-if t.TYPE_CHECKING:
+try:
     from sqlalchemy.ext.asyncio import AsyncConnection, AsyncTransaction
+except Exception:  # pragma: no cover
+    raise exceptions.DependencyNotInstalled(
+        dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy, dependant=__name__
+    )
+
 
 __all__ = ["SQLAlchemyWorker"]
 
@@ -17,11 +22,11 @@ class SQLAlchemyWorker(AbstractWorker):
     It will provide a connection and a transaction to the database and create the repositories for the entities.
     """
 
-    _connection: "AsyncConnection"
-    _transaction: "AsyncTransaction"
+    _connection: AsyncConnection
+    _transaction: AsyncTransaction
 
     @property
-    def connection(self) -> "AsyncConnection":
+    def connection(self) -> AsyncConnection:
         """Connection to the database.
 
         :return: Connection to the database.
@@ -33,7 +38,7 @@ def connection(self) -> "AsyncConnection":
             raise AttributeError("Connection not initialized")
 
     @property
-    def transaction(self) -> "AsyncTransaction":
+    def transaction(self) -> AsyncTransaction:
         """Database transaction.
 
         :return: Database transaction.
diff --git a/flama/resources/rest.py b/flama/resources/rest.py
index b11b1a57..6a4f4579 100644
--- a/flama/resources/rest.py
+++ b/flama/resources/rest.py
@@ -3,7 +3,7 @@
 import uuid
 
 from flama import exceptions
-from flama.ddd.repositories import SQLAlchemyTableRepository
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyTableRepository
 from flama.resources import data_structures
 from flama.resources.exceptions import ResourceAttributeError
 from flama.resources.resource import Resource, ResourceType
@@ -12,8 +12,9 @@
     import sqlalchemy
     from sqlalchemy.dialects import postgresql
 except Exception:  # pragma: no cover
-    sqlalchemy = None
-    postgresql = None
+    raise exceptions.DependencyNotInstalled(
+        dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy, dependant=__name__
+    )
 
 __all__ = ["RESTResource", "RESTResourceType"]
 
@@ -28,11 +29,6 @@ def __new__(mcs, name: str, bases: tuple[type], namespace: dict[str, t.Any]):
         :param bases: List of superclasses.
         :param namespace: Variables namespace used to create the class.
         """
-        if sqlalchemy is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy, dependant="RESTResourceType"
-            )
-
         if not mcs._is_abstract(namespace):
             try:
                 # Get model
@@ -68,12 +64,6 @@ def _get_model(cls, bases: t.Sequence[t.Any], namespace: dict[str, t.Any]) -> da
         :param namespace: Variables namespace used to create the class.
         :return: Resource model.
         """
-        if sqlalchemy is None or postgresql is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{cls.__module__}.{cls.__name__}",
-            )
-
         model = cls._get_attribute("model", bases, namespace, metadata_namespace="rest")
 
         # Already defined model probably because resource inheritance, so no need to create it
@@ -154,7 +144,7 @@ def _get_schemas(cls, name: str, bases: t.Sequence[t.Any], namespace: dict[str,
 
 
 class RESTResource(Resource, metaclass=RESTResourceType):
-    model: sqlalchemy.Table  # type: ignore
+    model: sqlalchemy.Table
     schema: t.Any
     input_schema: t.Any
     output_schema: t.Any
diff --git a/flama/resources/workers.py b/flama/resources/workers.py
index e53a7b33..e5f79860 100644
--- a/flama/resources/workers.py
+++ b/flama/resources/workers.py
@@ -1,11 +1,11 @@
 import typing as t
 
-from flama.ddd import SQLAlchemyWorker
+from flama.ddd.workers.sqlalchemy import SQLAlchemyWorker
 from flama.exceptions import ApplicationError
 
 if t.TYPE_CHECKING:
     from flama import Flama
-    from flama.ddd.repositories import SQLAlchemyTableRepository
+    from flama.ddd.repositories.sqlalchemy import SQLAlchemyTableRepository
 
 
 class FlamaWorker(SQLAlchemyWorker):
@@ -20,8 +20,8 @@ def __init__(self, app: t.Optional["Flama"] = None):
         """
 
         super().__init__(app)
-        self._repositories: dict[str, type["SQLAlchemyTableRepository"]] = {}  # type: ignore
-        self._init_repositories: t.Optional[dict[str, "SQLAlchemyTableRepository"]] = None
+        self._repositories: dict[str, type[SQLAlchemyTableRepository]] = {}  # type: ignore
+        self._init_repositories: t.Optional[dict[str, SQLAlchemyTableRepository]] = None
 
     @property
     def repositories(self) -> dict[str, "SQLAlchemyTableRepository"]:
diff --git a/flama/sqlalchemy.py b/flama/sqlalchemy.py
index 5b993d68..88889e5b 100644
--- a/flama/sqlalchemy.py
+++ b/flama/sqlalchemy.py
@@ -7,20 +7,14 @@
 
 try:
     import sqlalchemy
-    from sqlalchemy import MetaData
-    from sqlalchemy.ext.asyncio import create_async_engine
+    from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, AsyncTransaction, create_async_engine
 
-    metadata = MetaData()
+    metadata = sqlalchemy.MetaData()
 except Exception:  # pragma: no cover
-    sqlalchemy = None  # type: ignore[assignment]
-    metadata = None  # type: ignore[assignment]
-    create_async_engine = None  # type: ignore[assignment]
-
-if t.TYPE_CHECKING:
-    try:
-        from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, AsyncTransaction
-    except Exception:  # pragma: no cover
-        ...
+    raise exceptions.DependencyNotInstalled(
+        dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy, dependant=__name__
+    )
+
 
 __all__ = ["metadata", "SQLAlchemyModule"]
 
@@ -33,7 +27,7 @@ class ConnectionManager(abc.ABC):
     It will be used to manage the connections and transactions.
     """
 
-    def __init__(self, engine: "AsyncEngine") -> None:
+    def __init__(self, engine: AsyncEngine) -> None:
         """Initialize the connection manager.
 
         :param engine: SQLAlchemy engine.
@@ -41,7 +35,7 @@ def __init__(self, engine: "AsyncEngine") -> None:
         self._engine = engine
 
     @abc.abstractmethod
-    async def open(self) -> "AsyncConnection":
+    async def open(self) -> AsyncConnection:
         """Open a new connection to the database.
 
         :return: Database connection.
@@ -49,7 +43,7 @@ async def open(self) -> "AsyncConnection":
         ...
 
     @abc.abstractmethod
-    async def close(self, connection: "AsyncConnection") -> None:
+    async def close(self, connection: AsyncConnection) -> None:
         """Close the connection to the database.
 
         :param connection: Database connection.
@@ -57,7 +51,7 @@ async def close(self, connection: "AsyncConnection") -> None:
         ...
 
     @abc.abstractmethod
-    async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
+    async def begin(self, connection: AsyncConnection) -> AsyncTransaction:
         """Begin a new transaction.
 
         :param connection: Database connection to use for the transaction.
@@ -66,7 +60,7 @@ async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
         ...
 
     @abc.abstractmethod
-    async def end(self, transaction: "AsyncTransaction", *, rollback: bool = False) -> None:
+    async def end(self, transaction: AsyncTransaction, *, rollback: bool = False) -> None:
         """End a transaction.
 
         :param transaction: Database transaction.
@@ -85,19 +79,19 @@ class SingleConnectionManager(ConnectionManager):
     generate a nested transaction.
     """
 
-    def __init__(self, engine: "AsyncEngine") -> None:
+    def __init__(self, engine: AsyncEngine) -> None:
         """Initialize the connection manager.
 
         :param engine: SQLAlchemy engine.
         """
         super().__init__(engine)
-        self._connection: t.Optional["AsyncConnection"] = None
-        self._transaction: t.Optional["AsyncTransaction"] = None
+        self._connection: t.Optional[AsyncConnection] = None
+        self._transaction: t.Optional[AsyncTransaction] = None
         self._connection_clients = 0
         self._transaction_clients = 0
 
     @property
-    def connection(self) -> "AsyncConnection":
+    def connection(self) -> AsyncConnection:
         """Connection to the database.
 
         :return: Connection to the database.
@@ -109,7 +103,7 @@ def connection(self) -> "AsyncConnection":
         return self._connection
 
     @property
-    def transaction(self) -> "AsyncTransaction":
+    def transaction(self) -> AsyncTransaction:
         """Transaction to the database.
 
         :return: Transaction to the database.
@@ -120,7 +114,7 @@ def transaction(self) -> "AsyncTransaction":
 
         return self._transaction
 
-    async def open(self) -> "AsyncConnection":
+    async def open(self) -> AsyncConnection:
         """Open a new connection to the database.
 
         The first client will open a new connection, and subsequent clients will share this same connection.
@@ -136,7 +130,7 @@ async def open(self) -> "AsyncConnection":
         self._connection_clients += 1
         return connection
 
-    async def close(self, connection: "AsyncConnection") -> None:
+    async def close(self, connection: AsyncConnection) -> None:
         """Close the connection to the database.
 
         If this is the last client, the connection will be closed.
@@ -153,7 +147,7 @@ async def close(self, connection: "AsyncConnection") -> None:
             await connection.__aexit__(None, None, None)
             self._connection = None
 
-    async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
+    async def begin(self, connection: AsyncConnection) -> AsyncTransaction:
         """Begin a new transaction.
 
         The first client will create a new transaction, and subsequent clients will share this same transaction.
@@ -173,7 +167,7 @@ async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
         self._transaction_clients += 1
         return transaction
 
-    async def end(self, transaction: "AsyncTransaction", *, rollback: bool = False) -> None:
+    async def end(self, transaction: AsyncTransaction, *, rollback: bool = False) -> None:
         """End a transaction.
 
         If this is the last client, the connection will be committed or rolled back.
@@ -198,7 +192,7 @@ async def end(self, transaction: "AsyncTransaction", *, rollback: bool = False)
 class MultipleConnectionManager(ConnectionManager):
     """Connection manager that handlers several connections and transactions."""
 
-    def __init__(self, engine: "AsyncEngine") -> None:
+    def __init__(self, engine: AsyncEngine) -> None:
         """Initialize the connection manager.
 
         This manager keeps track of the connections and transactions, and it will close the connections when requested.
@@ -207,10 +201,10 @@ def __init__(self, engine: "AsyncEngine") -> None:
         :param engine: SQLAlchemy engine.
         """
         super().__init__(engine)
-        self._connections: set["AsyncConnection"] = set()
-        self._transactions: dict["AsyncConnection", "AsyncTransaction"] = {}
+        self._connections: set[AsyncConnection] = set()
+        self._transactions: dict[AsyncConnection, AsyncTransaction] = {}
 
-    async def open(self) -> "AsyncConnection":
+    async def open(self) -> AsyncConnection:
         """Open a new connection to the database.
 
         :return: Database connection.
@@ -220,7 +214,7 @@ async def open(self) -> "AsyncConnection":
         self._connections.add(connection)
         return connection
 
-    async def close(self, connection: "AsyncConnection") -> None:
+    async def close(self, connection: AsyncConnection) -> None:
         """Close the connection to the database.
 
         :param connection: Database connection.
@@ -235,7 +229,7 @@ async def close(self, connection: "AsyncConnection") -> None:
         self._connections.remove(connection)
         await connection.close()
 
-    async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
+    async def begin(self, connection: AsyncConnection) -> AsyncTransaction:
         """Begin a new transaction.
 
         :param connection: Database connection to use for the transaction.
@@ -252,7 +246,7 @@ async def begin(self, connection: "AsyncConnection") -> "AsyncTransaction":
         self._transactions[connection] = transaction
         return transaction
 
-    async def end(self, transaction: "AsyncTransaction", *, rollback: bool = False) -> None:
+    async def end(self, transaction: AsyncTransaction, *, rollback: bool = False) -> None:
         """End a transaction.
 
         :param transaction: Database transaction.
@@ -307,28 +301,22 @@ def __init__(
         :param engine_args: Arguments to pass to the SQLAlchemy engine.
         :raises ApplicationError: If SQLAlchemy is not installed.
         """
-        if sqlalchemy is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         if not database:
             raise exceptions.ApplicationError("Database connection string must be provided")
 
         super().__init__()
 
         self.database = database
-        self.metadata: "MetaData" = metadata  # type: ignore[assignment]
-        self._engine: t.Optional["AsyncEngine"] = None
+        self.metadata: sqlalchemy.MetaData = metadata
+        self._engine: t.Optional[AsyncEngine] = None
         self._engine_args = engine_args or {}
-        self._connection_manager: t.Optional["ConnectionManager"] = None
-        self._manager_cls: type["ConnectionManager"] = (
+        self._connection_manager: t.Optional[ConnectionManager] = None
+        self._manager_cls: type[ConnectionManager] = (
             SingleConnectionManager if single_connection else MultipleConnectionManager
         )
 
     @property
-    def engine(self) -> "AsyncEngine":
+    def engine(self) -> AsyncEngine:
         """SQLAlchemy engine.
 
         :return: SQLAlchemy engine.
@@ -349,21 +337,21 @@ def connection_manager(self) -> "ConnectionManager":
             raise exceptions.ApplicationError("SQLAlchemyModule not initialized")
         return self._connection_manager
 
-    async def open_connection(self) -> "AsyncConnection":
+    async def open_connection(self) -> AsyncConnection:
         """Open a new connection to the database.
 
         :return: Database connection.
         """
         return await self.connection_manager.open()
 
-    async def close_connection(self, connection: "AsyncConnection") -> None:
+    async def close_connection(self, connection: AsyncConnection) -> None:
         """Close the connection to the database.
 
         :param connection: Database connection.
         """
         return await self.connection_manager.close(connection)
 
-    async def begin_transaction(self, connection: "AsyncConnection") -> "AsyncTransaction":
+    async def begin_transaction(self, connection: AsyncConnection) -> AsyncTransaction:
         """Begin a new transaction.
 
         :param connection: Database connection to use for the transaction.
@@ -371,7 +359,7 @@ async def begin_transaction(self, connection: "AsyncConnection") -> "AsyncTransa
         """
         return await self.connection_manager.begin(connection)
 
-    async def end_transaction(self, transaction: "AsyncTransaction", *, rollback: bool = False) -> None:
+    async def end_transaction(self, transaction: AsyncTransaction, *, rollback: bool = False) -> None:
         """End a transaction.
 
         :param transaction: Database transaction.
@@ -382,12 +370,6 @@ async def end_transaction(self, transaction: "AsyncTransaction", *, rollback: bo
 
     async def on_startup(self):
         """Initialize the SQLAlchemy engine and connection manager."""
-        if create_async_engine is None:
-            raise exceptions.DependencyNotInstalled(
-                dependency=exceptions.DependencyNotInstalled.Dependency.sqlalchemy,
-                dependant=f"{self.__class__.__module__}.{self.__class__.__name__}",
-            )
-
         self._engine = create_async_engine(self.database, **self._engine_args)
         self._connection_manager = self._manager_cls(self._engine)
 
diff --git a/tests/ddd/repositories/test_sqlalchemy.py b/tests/ddd/repositories/test_sqlalchemy.py
index 6dbff7a1..ce4c312e 100644
--- a/tests/ddd/repositories/test_sqlalchemy.py
+++ b/tests/ddd/repositories/test_sqlalchemy.py
@@ -6,7 +6,8 @@
 from sqlalchemy.ext.asyncio import AsyncConnection
 
 from flama import Flama
-from flama.ddd import SQLAlchemyRepository, SQLAlchemyTableManager, SQLAlchemyTableRepository, exceptions
+from flama.ddd import exceptions
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyRepository, SQLAlchemyTableManager, SQLAlchemyTableRepository
 from flama.sqlalchemy import SQLAlchemyModule
 from tests.utils import SQLAlchemyContext
 
diff --git a/tests/ddd/workers/test_sqlalchemy.py b/tests/ddd/workers/test_sqlalchemy.py
index c8b5ecd7..350a419e 100644
--- a/tests/ddd/workers/test_sqlalchemy.py
+++ b/tests/ddd/workers/test_sqlalchemy.py
@@ -3,8 +3,8 @@
 import pytest
 from sqlalchemy.ext.asyncio import AsyncConnection
 
-from flama.ddd.repositories import SQLAlchemyRepository
-from flama.ddd.workers import SQLAlchemyWorker
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyRepository
+from flama.ddd.workers.sqlalchemy import SQLAlchemyWorker
 
 
 class TestCaseSQLAlchemyWorker:
diff --git a/tests/resources/test_resource.py b/tests/resources/test_resource.py
index 5c1a40cd..136addb2 100644
--- a/tests/resources/test_resource.py
+++ b/tests/resources/test_resource.py
@@ -2,7 +2,7 @@
 import sqlalchemy
 
 from flama.applications import Flama
-from flama.ddd.repositories import SQLAlchemyRepository
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyRepository
 from flama.resources import data_structures
 from flama.resources.crud import CRUDResource
 from flama.resources.routing import resource_method
diff --git a/tests/resources/test_rest.py b/tests/resources/test_rest.py
index 5757d33c..9b6b4590 100644
--- a/tests/resources/test_rest.py
+++ b/tests/resources/test_rest.py
@@ -2,7 +2,7 @@
 import sqlalchemy
 
 from flama.applications import Flama
-from flama.ddd.repositories import SQLAlchemyRepository
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyRepository
 from flama.resources import data_structures
 from flama.resources.rest import RESTResource
 from flama.sqlalchemy import SQLAlchemyModule, metadata
diff --git a/tests/resources/test_workers.py b/tests/resources/test_workers.py
index 3e5bfe75..6d41b3fb 100644
--- a/tests/resources/test_workers.py
+++ b/tests/resources/test_workers.py
@@ -2,7 +2,7 @@
 
 from flama import Flama
 from flama.client import Client
-from flama.ddd.repositories import SQLAlchemyRepository
+from flama.ddd.repositories.sqlalchemy import SQLAlchemyRepository
 from flama.exceptions import ApplicationError
 from flama.resources.workers import FlamaWorker
 from flama.sqlalchemy import SQLAlchemyModule
diff --git a/tests/test_sqlalchemy.py b/tests/test_sqlalchemy.py
index 6242260d..d5edcdb5 100644
--- a/tests/test_sqlalchemy.py
+++ b/tests/test_sqlalchemy.py
@@ -233,13 +233,6 @@ async def test_lifespan_cycle(self, uri, exception):
             assert app.sqlalchemy._engine is None
             assert app.sqlalchemy._connection_manager is None
 
-    def test_sqlalchemy_not_installed(self):
-        with patch("flama.sqlalchemy.sqlalchemy", new=None), pytest.raises(
-            ApplicationError,
-            match=r"Dependency 'sqlalchemy\[asyncio\]' must be installed to use 'flama.sqlalchemy.SQLAlchemyModule'",
-        ):
-            SQLAlchemyModule("")
-
     def test_engine_not_initialized(self, app):
         with pytest.raises(ApplicationError, match="SQLAlchemyModule not initialized"):
             app.sqlalchemy.engine