Interfaces rewrite (#55)

* Replaces Protocols with Abstract Base Classes in the `sqlalchemy_bind_manager.repository` module

* The `SortDirection` enum has been replaced by literal `"asc"` or `"desc"`

* Remove `SQLAlchemyAsyncConfig ` and use `SQLAlchemyConfig` for async engines

* Documentation update

Author: febus982

docs/api_reference/bind_manager.md

@@ -3,4 +3,3 @@
       members:
       - SQLAlchemyBindManager 
       - SQLAlchemyConfig 
-      - SQLAlchemyAsyncConfig 

docs/api_reference/repository.md

@@ -1,9 +1,9 @@
-::: sqlalchemy_bind_manager.protocols
+::: sqlalchemy_bind_manager.repository
     options:
       members:
-      - SQLAlchemyRepositoryInterface
-      - SQLAlchemyAsyncRepositoryInterface
-      - SortDirection
+      - SQLAlchemyRepository
+      - SQLAlchemyAsyncRepository
       - PaginatedResult
+      - PageInfo
       - CursorPaginatedResult
-      - CursorReference
+      - CursorPageInfo

docs/manager/alembic/env.py

@@ -6,14 +6,14 @@
 from sqlalchemy import Column, Integer, String
 from sqlalchemy.ext.asyncio import AsyncEngine
 
-from sqlalchemy_bind_manager import SQLAlchemyAsyncConfig, SQLAlchemyBindManager
+from sqlalchemy_bind_manager import SQLAlchemyConfig, SQLAlchemyBindManager
 
 ################################################################
 ## Note: The bind_config, sa_manager and models are normally  ##
 ## implemented in an application. This is only an example!    ##
 ################################################################
 bind_config = {
-    "default": SQLAlchemyAsyncConfig(
+    "default": SQLAlchemyConfig(
         engine_url=f"sqlite+aiosqlite:///{os.path.dirname(os.path.abspath(__file__))}/sqlite.db",
         engine_options=dict(
             connect_args={
@@ -22,6 +22,7 @@
             echo=False,
             future=True,
         ),
+        async_engine=True,
     ),
 }
 

docs/manager/config.md

@@ -63,13 +63,14 @@ All the `SQLAlchemyBindManager` helper methods accept the `bind_name` optional p
 
 ## Asynchronous database engines
 
-Is it possible to supply configurations for asyncio supported engines using `SQLAlchemyAsyncConfig` objects.
+Is it possible to supply configurations for asyncio supported engines using the `async_engine` config property.
 
 ```python
-from sqlalchemy_bind_manager import SQLAlchemyAsyncConfig, SQLAlchemyBindManager
+from sqlalchemy_bind_manager import SQLAlchemyConfig, SQLAlchemyBindManager
 
-config = SQLAlchemyAsyncConfig(
+config = SQLAlchemyConfig(
     engine_url="postgresql+asyncpg://scott:tiger@localhost/test",
+    async_engine=True,
 )
 
 sa_manager = SQLAlchemyBindManager(config)

docs/repository/usage.md

@@ -35,27 +35,29 @@ The classes provide some common use methods:
 * `paginated_find`: Search for a list of models, with pagination support
 * `cursor_paginated_find`: Search for a list of models, with cursor based pagination support
 
-/// details | Typing and Protocols
+/// details | Typing and Interfaces
     type: tip
 
-The repository classes are fully typed (as the rest of this package), but
-protocols classes are provided as addition to allow more decoupled type checking
+The repository classes are fully typed (as the rest of this package). The repositories
+implement interface classes that are available to allow better code decoupling
 and inversion of control patterns such as
 [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection).
 
 ```python
-from sqlalchemy_bind_manager.protocols import SQLAlchemyRepositoryInterface, SQLAlchemyAsyncRepositoryInterface
+from sqlalchemy_bind_manager.repository import SQLAlchemyRepositoryInterface, SQLAlchemyAsyncRepositoryInterface
+
 
 def some_function(repository: SQLAlchemyRepositoryInterface[MyModel]):
     model = repository.get(123)
     ...
 
+
 async def some_async_function(repository: SQLAlchemyAsyncRepositoryInterface[MyModel]):
     model = await repository.get(123)
     ...
 ```
 
-Both repository and related protocols are Generic, accepting the model class as argument.
+Both repository and related interface are Generic, accepting the model class as a typing argument.
 ///
 
 ### Maximum query limit

sqlalchemy_bind_manager/__init__.py

@@ -19,7 +19,6 @@
 #  DEALINGS IN THE SOFTWARE.
 
 from ._bind_manager import (
-    SQLAlchemyAsyncConfig,
     SQLAlchemyBindManager,
     SQLAlchemyConfig,
 )

sqlalchemy_bind_manager/_bind_manager.py

@@ -20,7 +20,7 @@
 
 from typing import Mapping, MutableMapping, Union
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, StrictBool
 from sqlalchemy import MetaData, create_engine
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import (
@@ -40,22 +40,13 @@
 
 class SQLAlchemyConfig(BaseModel):
     """
-    Configuration for synchronous engines
-    """
-
-    engine_url: str
-    engine_options: Union[dict, None] = None
-    session_options: Union[dict, None] = None
-
-
-class SQLAlchemyAsyncConfig(BaseModel):
-    """
-    Configuration for asynchronous engines
+    Configuration for engines
     """
 
     engine_url: str
     engine_options: Union[dict, None] = None
     session_options: Union[dict, None] = None
+    async_engine: StrictBool = False
 
 
 class SQLAlchemyBind(BaseModel):
@@ -85,9 +76,8 @@ class SQLAlchemyBindManager:
     def __init__(
         self,
         config: Union[
-            Mapping[str, Union[SQLAlchemyConfig, SQLAlchemyAsyncConfig]],
+            Mapping[str, SQLAlchemyConfig],
             SQLAlchemyConfig,
-            SQLAlchemyAsyncConfig,
         ],
     ) -> None:
         self.__binds = {}
@@ -97,18 +87,10 @@ def __init__(
         else:
             self.__init_bind(DEFAULT_BIND_NAME, config)
 
-    def __init_bind(
-        self, name: str, config: Union[SQLAlchemyConfig, SQLAlchemyAsyncConfig]
-    ):
-        if not any(
-            [
-                isinstance(config, SQLAlchemyConfig),
-                isinstance(config, SQLAlchemyAsyncConfig),
-            ]
-        ):
+    def __init_bind(self, name: str, config: SQLAlchemyConfig):
+        if not isinstance(config, SQLAlchemyConfig):
             raise InvalidConfigError(
-                f"Config for bind `{name}` is not a SQLAlchemyConfig"
-                f" or SQLAlchemyAsyncConfig object"
+                f"Config for bind `{name}` is not a SQLAlchemyConfig" f"object"
             )
 
         engine_options: dict = config.engine_options or {}
@@ -119,7 +101,7 @@ def __init_bind(
         session_options.setdefault("expire_on_commit", False)
         session_options.setdefault("autobegin", False)
 
-        if isinstance(config, SQLAlchemyAsyncConfig):
+        if config.async_engine:
             self.__binds[name] = self.__build_async_bind(
                 engine_url=config.engine_url,
                 engine_options=engine_options,

sqlalchemy_bind_manager/_repository/__init__.py

@@ -18,11 +18,13 @@
 #  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 #  DEALINGS IN THE SOFTWARE.
 
+from .abstract import SQLAlchemyAsyncRepositoryInterface, SQLAlchemyRepositoryInterface
 from .async_ import SQLAlchemyAsyncRepository
 from .common import (
+    CursorPageInfo,
     CursorPaginatedResult,
     CursorReference,
+    PageInfo,
     PaginatedResult,
-    SortDirection,
 )
 from .sync import SQLAlchemyRepository