updates

Author: JacobFV

README.md

@@ -0,0 +1,64 @@
+# The Object API
+
+ObjectAPI provides a concise negative-boilerplate paradigm for creating full-stack web applications with Python. It is built on top of [FastAPI](https://fastapi.tiangolo.com/), [SQLModel](https://sqlmodel.tiangolo.com/), and [pydantic](https://docs.pydantic.dev/latest/).
+
+## Features
+
+- Active record pattern for database access
+- Automatic get_by_id lookup for instance methods with route decorators
+- Automatic CRUD routes
+- Scheduled service methods
+- Managed DB sessions for service methods and for each request
+
+## Installation
+
+```bash
+pip install object-api
+```
+
+## Usage
+
+```python
+from object_api import App, Entity, RouterBuilder, ServiceBuilder
+
+app = App()
+
+class User(Entity):
+    class Meta:
+        service = ServiceBuilder()
+        router = RouterBuilder()
+
+        new_private = ["pass"]
+
+    name: str
+    pass: str
+    age: int
+
+    @service.servicemethod
+    @classmethod
+    def remove_inactive(cls):
+        for user in User.get_all():
+            if user.age > 100:
+                user.delete()
+    
+    @router.route()
+    def get_name(self):
+        return self.name
+
+    @router.post("/change_name")
+    def change_name(self, name: str):
+        self.name = name
+        self.save()
+
+app = App()
+
+app.run()
+```
+
+## Documentation
+
+<https://github.com/ComputaCo/object-api>
+
+## License
+
+[MIT](https://choosealicense.com/licenses/mit/)

object_api/__init__.py

@@ -0,0 +1,4 @@
+from object_api.entity import Entity
+from object_api.app import App
+from object_api.router_builder import RouterBuilder
+from object_api.service_builder import ServiceBuilder

object_api/app.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
-from contextlib import contextmanager
+
+from contextlib import asynccontextmanager, contextmanager
 from typing import Generator
-from fastapi import FastAPI
-from pydantic import Field
-from sqlalchemy.future.engine import Engine
 
-from scheduler import Scheduler
+from sqlalchemy.future.engine import Engine
 from sqlmodel import SQLModel, Session, create_engine
+from pydantic import Field
+from fastapi import FastAPI
+from scheduler import Scheduler
 
 from object_api.entity import Entity
+from object_api.request_context import RequestContextMiddleware, get_request_id
 from object_api.utils.has_post_init import HasPostInitMixin
 
 
 class App(FastAPI, HasPostInitMixin):
     CURRENT_APP: App = Field(None, init=False)
 
-    scheduler: Scheduler = Field(default_factory=Scheduler, init=False)
+    scheduler: Scheduler = Field(
+        default_factory=lambda: Scheduler(n_threads=0), init=False
+    )
     entity_classes: list[type[Entity]] = Field([], init=False)
     db_engine: Engine = Field(None, init=False)
     debug: bool = True
@@ -30,6 +34,7 @@ def __post_init__(self):
             )
         self.CURRENT_APP = self
 
+        self.add_middleware(RequestContextMiddleware)
         self.build()
 
         return super().__post_init__()
@@ -50,25 +55,45 @@ def build_routers(self):
         for entity_class in self.entity_classes:
             entity_class.Meta.router.build_router(entity_class)
 
-    _object_api_app_active_session: Session = Field(None, init=False)
+    # The servicemethods will just have to manually pass the session to their invoked service methods
+    _per_thread_active_session: dict[str, Session] = Field(None, init=False)
 
-    @contextmanager
+    @asynccontextmanager
     async def session(self) -> Generator[None, None, None]:
-        if self._object_api_app_active_session:
-            if not self._object_api_app_active_session.is_active:
-                raise RuntimeError(
-                    "Session is already closed. Please use a new session for each request."
-                )
-
-            yield self._object_api_app_active_session
+        """Returns (and possibly creates) a session for the current req-response cycle
+        or returns a globally shared session if no request context is available."""
+        req_id = get_request_id() or "global"
+
+        # maybe create or re-initialize the session if its non-existent or inactive
+        if (
+            req_id not in self._per_thread_active_session
+            or not self._per_thread_active_session[req_id]
+            or not self._per_thread_active_session[req_id].is_active
+        ):
+            self._per_thread_active_session[req_id] = Session(self.db_engine)
+
+        # now enter the session context or just yield the session if it's already active
+        if self._per_thread_active_session[req_id].is_active:
+            yield self._per_thread_active_session[req_id]
             return
+        else:
+            with self._per_thread_active_session[req_id] as session:
+                yield session
+            # make sure to clean up the session after the request is done
+            del self._per_thread_active_session[req_id]
+            return
+
+    @asynccontextmanager
+    @staticmethod
+    async def current_session() -> Generator[Session, None, None]:
+        if not App.CURRENT_APP:
+            raise RuntimeError(
+                "No current app. Please use App.as_current() to set the current app."
+            )
 
-        with Session(self.db_engine) as session:
-            self._object_api_app_active_session = session
-            yield session
-            self._object_api_app_active_session = None
+        yield App.CURRENT_APP.session()
 
-    @contextmanager
+    @asynccontextmanager
     async def as_current(self) -> Generator[App, None, None]:
         old_app = self.CURRENT_APP
         self.CURRENT_APP = self