Generalized database function type args, fixed syntax

app/database.py

@@ -1,3 +1,4 @@
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlmodel import Session, SQLModel, create_engine, select
 
 from app.config import settings
@@ -13,82 +14,95 @@ def create_database():
     SQLModel.metadata.create_all(engine)
 
 
+### POST route
 def add_to_database(input: SQLModel):
     with Session(engine) as session:
         session.add(input)
         session.commit()
 
 
-def get_from_database(query: type[SQLModel]):
+### GET "/all" route
+def get_from_database[T: SQLModel](query: type[T]) -> list[T] | None:
     with Session(engine) as session:
-        results = session.exec(select(query)).all()
+        results = list(session.exec(select(query)))
     return results
 
 
-def get_from_database_where(
-    query: type[SQLModel],
-    variable: object,
-    value: int | str | None,
-    first_only: bool = False,
+### GET "/{value_of_var}" route
+def get_from_database_where[T: SQLModel, V](
+    query: type[T],
+    variable: InstrumentedAttribute[V],
+    value: V,
     offset: int | None = None,
     limit: int | None = None,
-):
+) -> list[T] | None:
     with Session(engine) as session:
         statement = select(query).where(variable == value)
-        if offset:
+        if offset is not None:
             statement = statement.offset(offset)
-        if limit:
+        if limit is not None:
             statement = statement.limit(limit)
-        results = session.exec(statement)
-        if first_only:
-            results = results.first()
-        else:
-            results = results.all()
+        results = list(session.exec(statement))
     return results
 
 
-def get_from_database_where_id(
-    query: type[SQLModel],
+### GET "/{id}" route
+def get_from_database_where_id[T: SQLModel](
+    query: type[T],
     value: int,
-) -> SQLModel | None:
+) -> T | None:
     with Session(engine) as session:
         result = session.get(query, value)
     return result
 
 
-def get_from_database_where_join_filter(
-    query: type[SQLModel],
-    joined: type[SQLModel],
-    variable: object,
-    value: int | str | None,
-):
+### GET "/{value where x for y and y has link to z}" route
+def get_from_database_where_join_filter[
+    T: SQLModel,
+    K: SQLModel,
+    V,
+](
+    query: type[T],
+    joined: type[K],
+    variable: InstrumentedAttribute[V],
+    value: V,
+) -> list[T] | None:
     with Session(engine) as session:
-        results = session.exec(select(query).join(joined).where(variable == value))
+        results = list(
+            session.exec(select(query).join(joined).where(variable == value))
+        )
     return results
 
 
-def get_and_join_from_database(
-    query: type[SQLModel],
-    joined: type[SQLModel],
+### GET "/{with table y}" route (can have outers or not)
+def get_and_join_from_database[
+    T: SQLModel,
+    K: SQLModel,
+](
+    query: type[T],
+    joined: type[K],
     isouter: bool = False,
-):
+) -> list[tuple[T, K]] | None:
     with Session(engine) as session:
-        results = session.exec(select(query, joined).join(joined, isouter=isouter))
+        results = list(
+            session.exec(select(query, joined).join(joined, isouter=isouter))
+        )
     return results
 
 
-def update_database_where(
-    query: type[SQLModel],
-    variable: object,
-    value: int | str | None,
-    attribute: str,
-    new_value: int | str | None,
-):
+### PATCH "/{value_of_var}" route
+def update_database_where[T: SQLModel, V, W](
+    query: type[T],
+    variable: InstrumentedAttribute[V],
+    value: V,
+    attribute: InstrumentedAttribute[W],
+    new_value: W,
+) -> list[T]:
     with Session(engine) as session:
         results = list(session.exec(select(query).where(variable == value)))
 
         for instance in results:
-            setattr(instance, attribute, new_value)
+            setattr(instance, attribute.key, new_value)
             session.add(instance)
 
         session.commit()
@@ -98,18 +112,18 @@ def update_database_where(
     return results
 
 
-def delete_from_database_where(
-    query: type[SQLModel],
-    variable: object,
-    value: str | int | None,
-):
+### DELETE "/{value_of_var}" route
+def delete_from_database_where[T: SQLModel, V](
+    query: type[T],
+    variable: InstrumentedAttribute[V],
+    value: V,
+) -> list[T]:
     with Session(engine) as session:
-        results = session.exec(select(query).where(variable == value))
+        results = list(session.exec(select(query).where(variable == value)))
 
         for instance in results:
             session.delete(instance)
 
         session.commit()
 
-        remainder = session.exec(select(query).where(variable == value)).all()
-    return remainder
+    return results