Fixed bug where async session was not yieleded correctly

Author: reinhud

README.md

@@ -11,7 +11,7 @@ services:
     volumes:    # dont use this in production, mounting docker volume to location on my machine where to store postgres data for docker
       - ./docker_pg_data/postgres-data:/var/lib/postgresql/data
     env_file:
-      - prod.env
+      - .env
     networks:
       app1_net:
         ipv4_address: 192.168.0.2
@@ -26,7 +26,7 @@ services:
     volumes:
      - ./docker_pg_data/pgadmin-data:/var/lib/pgadmin
     env_file:
-      - prod.env
+      - .env
     depends_on:
       - db
     networks:
@@ -37,19 +37,16 @@ services:
   fastapi_server:
     container_name: fastapi_server_container
     build: 
-      context: ./microservices/fastapi_server
+      context: ./fastapi_server
       dockerfile: Dockerfile
     working_dir: /fastapi_server
     ports:
       - "8001:8001"
-    command: >
-        bash -c "uvicorn app.fastapi_server:app --reload --workers 1 --host 0.0.0.0 --port 8001
-        && alembic revision --autogenerate -m "Current DB state"
-        && alembic upgrade head"
+    command: bash -c "uvicorn app.fastapi_server:app --reload --workers 1 --host 0.0.0.0 --port 8001"
     volumes:
-     - ./microservices/fastapi_server:/fastapi_server    # used for live reloading of container to changes in app on local machine
+     - ./fastapi_server:/fastapi_server    # used for live reloading of container to changes in app on local machine
     env_file:
-      - prod.env
+      - .env
     depends_on:
       - db
     networks:

src/docker-compose.yml

@@ -20,18 +20,20 @@ async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
     All conversations with the database are established via the session
     objects. Also. the sessions act as holding zone for ORM-mapped objects.
     """
-    async_Session = sessionmaker(
+    logger.warning("Trying to get async engine")
+    async_session = sessionmaker(
         bind=get_async_engine(), 
         class_=AsyncSession, 
         autoflush=False,
         expire_on_commit=False,   # document this
     )
-    async with async_Session as a_sess:
+    logger.warning("Success with async engine")
+    async with async_session() as async_sess:
+        logger.warning("In session loop")
         try:
-            yield a_sess
+            yield async_sess
+            logger.warning("yielded session")
         except SQLAlchemyError as e:
             logger.error("Unable to yield session in database dependency")
             logger.error(e)
-        
-
-    
+        

src/microservices/fastapi_server/Dockerfile renamed to src/fastapi_server/Dockerfile

@@ -3,13 +3,15 @@
 TODO:
     1. do funcs need to be async?
 """
-from typing import Callable, Type
+from typing import Callable, Type, TypeVar
 
 from fastapi import Depends
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app._utils._types import SQLA_REPO_TYPE
 from app.api.dependencies.database import get_async_session
+from app.db.repositories.base import SQLAlchemyRepository
+
+SQLA_REPO_TYPE = TypeVar("SQLA_REPO_TYPE", bound=SQLAlchemyRepository)
 
 
 # Repo dependency

src/microservices/fastapi_server/__init__.py renamed to src/fastapi_server/__init__.py

@@ -15,5 +15,3 @@ def get_async_engine() -> AsyncEngine:
     return async_engine
 
 
-        
-        

src/microservices/fastapi_server/alembic.ini renamed to src/fastapi_server/alembic.ini

@@ -1,16 +1,24 @@
 """Abstract CRUD Repo definitions."""
 from abc import ABC
-from typing import List
+from typing import List, TypeVar
 
 from loguru import logger
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app._utils._types import CREATE_SCHEMA, READ_MULTIPLE_SCHEMA, SQLA_MODEL
-from app.db.models.base import BaseSaModel
+from app.db.models.base import Base
 from app.models.base import BaseSchema
 
+## ===== Custom Type Hints ===== ##
+# sqlalchemy models
+SQLA_MODEL = TypeVar("SQLA_MODEL", bound=Base)
 
+# pydantic models
+CREATE_SCHEMA = TypeVar("CREATE_SCHEMA", bound=BaseSchema)
+READ_MULTIPLE_SCHEMA = TypeVar("READ_MULTIPLE_SCHEMA", bound=BaseSchema)
+
+
+## ===== CRUD Repo ===== ##
 class SQLAlchemyRepository(ABC):
     """Abstract SQLAlchemy repo defining basic database operations.
     
@@ -24,15 +32,15 @@ def __init__(
         self.db = db
 
     # models and schemas object instanziation and validation
-    sqla_model: SQLA_MODEL
+    sqla_model = SQLA_MODEL
 
-    create_Schema: CREATE_SCHEMA
-    read_multiple_schema: READ_MULTIPLE_SCHEMA
+    create_schema =  CREATE_SCHEMA
+    read_multiple_schema = READ_MULTIPLE_SCHEMA
 
     ## ===== Basic Crud Operations ===== ##
     async def create(
         self, 
-        obj_new: create_Schema
+        obj_new: create_schema
         ) -> sqla_model | None:
         """Commit new object to the database."""
         try:

src/microservices/fastapi_server/app/__init__.py renamed to src/fastapi_server/app/__init__.py

@@ -16,7 +16,7 @@ class UserRepository(SQLAlchemyRepository):
     """
     sqla_model = UserModel
 
-    create_Schema = UserCreate
+    create_schema = UserCreate
     read_multiple_schema = UserQueryOptionalSchema
 
 

src/microservices/fastapi_server/app/_utils/__init__.py renamed to src/fastapi_server/app/_utils/__init__.py

@@ -1,6 +1,9 @@
 """Testing user endpoints.
 
 More like unit tests, we're mocking the actual database calls here.
+
+TODO:
+    1. Implement method to test 'read_multiple' asserting streaming results
 """
 from fastapi import status
 from fastapi.encoders import jsonable_encoder
@@ -73,10 +76,10 @@ async def test_read_multiple_users_OK(
 
         async def mock_read_optional(self, query_schema):
             return Users_Output
-        monkeypatch.setattr(SQLAlchemyRepository, "read_optional", mock_read_optional)
+        monkeypatch.setattr(SQLAlchemyRepository, "read_multiple", mock_read_optional)
 
         res = await async_test_client.post(
-            "/api/user/get_optional",
+            "/api/user/get_multiple",
             json=query_schema
         )