sera-2 1.2.1__py3-none-any.whl → 1.4.2__py3-none-any.whl

sera/constants.py

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+# Constant representing an unassigned integer ID
+NO_INT_ID: int = None  # type: ignore

sera/libs/base_orm.py

@@ -73,7 +73,7 @@ class ListDataclassType(TypeDecorator):
         return [self.cls.from_dict(x) for x in result]
 
 
-class DictDataClassType(TypeDecorator):
+class DictDataclassType(TypeDecorator):
     """SqlAlchemy Type decorator to serialize mapping of dataclasses"""
 
     impl = LargeBinary

sera/libs/base_service.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Annotated, Any, Generic, Optional, Sequence, TypeVar
+from math import dist
+from typing import Annotated, Any, Generic, NamedTuple, Optional, Sequence, TypeVar
 
 from sera.libs.base_orm import BaseORM
 from sera.misc import assert_not_null
 from sera.models import Class
 from sera.typing import FieldName, T, doc
-from sqlalchemy import exists, select
-from sqlalchemy.orm import Session
+from sqlalchemy import Result, Select, exists, func, select
+from sqlalchemy.orm import Session, load_only
 
 
 class QueryOp(str, Enum):
@@ -31,6 +32,12 @@ Query = Annotated[
 ]
 R = TypeVar("R", bound=BaseORM)
 ID = TypeVar("ID")  # ID of a class
+SqlResult = TypeVar("SqlResult", bound=Result)
+
+
+class QueryResult(NamedTuple, Generic[R]):
+    records: Sequence[R]
+    total: int
 
 
 class BaseService(Generic[ID, R]):
@@ -52,7 +59,7 @@ class BaseService(Generic[ID, R]):
         group_by: list[str],
         fields: list[str],
         session: Session,
-    ) -> Sequence[R]:
+    ) -> QueryResult[R]:
         """Retrieving records matched a query.
 
         Args:
@@ -62,14 +69,35 @@ class BaseService(Generic[ID, R]):
             unique: Whether to return unique results only
             sorted_by: list of field names to sort by, prefix a field with '-' to sort that field in descending order
             group_by: list of field names to group by
-            fields: list of field names to include in the results
+            fields: list of field names to include in the results -- empty means all fields
         """
-        return []
+        q = self._select()
+        if fields:
+            q = q.options(
+                load_only(*[getattr(self.orm_cls, field) for field in fields])
+            )
+        if unique:
+            q = q.distinct()
+        if sorted_by:
+            for field in sorted_by:
+                if field.startswith("-"):
+                    q = q.order_by(getattr(self.orm_cls, field[1:]).desc())
+                else:
+                    q = q.order_by(getattr(self.orm_cls, field))
+        if group_by:
+            for field in group_by:
+                q = q.group_by(getattr(self.orm_cls, field))
+
+        cq = select(func.count()).select_from(q.subquery())
+        rq = q.limit(limit).offset(offset)
+        records = self._process_result(session.execute(q)).scalars().all()
+        total = session.execute(cq).scalar_one()
+        return QueryResult(records, total)
 
     def get_by_id(self, id: ID, session: Session) -> Optional[R]:
         """Retrieving a record by ID."""
-        q = select(self.orm_cls).where(self._cls_id_prop == id)
-        result = session.execute(q).scalar_one_or_none()
+        q = self._select().where(self._cls_id_prop == id)
+        result = self._process_result(session.execute(q)).scalar_one_or_none()
         return result
 
     def has_id(self, id: ID, session: Session) -> bool:
@@ -89,3 +117,11 @@ class BaseService(Generic[ID, R]):
         session.add(record)
         session.commit()
         return record
+
+    def _select(self) -> Select:
+        """Get the select statement for the class."""
+        return select(self.orm_cls)
+
+    def _process_result(self, result: SqlResult) -> SqlResult:
+        """Process the result of a query."""
+        return result

sera/make/__main__.py

@@ -5,6 +5,7 @@ from typing import Annotated
 
 import typer
 from sera.make.make_app import make_app
+from sera.models import Language
 
 app = typer.Typer(pretty_exceptions_short=True, pretty_exceptions_enable=False)
 
@@ -29,10 +30,22 @@ def cli(
             help="API collections to generate.",
         ),
     ],
+    language: Annotated[
+        Language,
+        typer.Option("-l", "--language", help="Language of the generated application"),
+    ] = Language.Python,
+    referenced_schema: Annotated[
+        list[str],
+        typer.Option(
+            "-rs",
+            "--referenced-schema",
+            help="Classes in the schema that are defined in different modules, used as references and thus should not be generated.",
+        ),
+    ] = [],
 ):
     """Generate Python model classes from a schema file."""
     typer.echo(f"Generating application in {app_dir}")
-    make_app(app_dir, schema_files, api_collections)
+    make_app(app_dir, schema_files, api_collections, language, referenced_schema)
 
 
 app()

sera/make/make_app.py

@@ -13,6 +13,7 @@ from sera.make.make_python_model import (
     make_python_relational_model,
 )
 from sera.make.make_python_services import make_python_service_structure
+from sera.make.make_typescript_model import make_typescript_data_model
 from sera.models import App, DataCollection, Language, parse_schema
 
 
@@ -62,8 +63,8 @@ def make_config(app: App):
             expr.ExprIdent('os.environ.get("DB_DEBUG", "0") == "1"'),
         ),
         lambda ast: ast.assign(
-            DeferredVar.simple("ROUTER_DEBUG"),
-            expr.ExprIdent('os.environ.get("ROUTER_DEBUG", "0") == "1"'),
+            DeferredVar.simple("API_DEBUG"),
+            expr.ExprIdent('os.environ.get("API_DEBUG", "0") == "1"'),
         ),
         stmt.LineBreak(),
         lambda ast: ast.assign(
@@ -113,25 +114,54 @@ def make_app(
             "Language of the generated application. Currently only Python is supported."
         ),
     ] = Language.Python,
+    referenced_schema: Annotated[
+        list[str],
+        doc(
+            "Classes in the schema that are defined in different modules, used as references and thus should not be generated."
+        ),
+    ] = [],
 ):
     schema = parse_schema(schema_files)
 
     app = App(app_dir.name, app_dir, schema_files, language)
 
-    # generate application configuration
-    make_config(app)
-
-    # generate models from schema
-    make_python_data_model(schema, app.models.pkg("data"))
-    make_python_relational_model(schema, app.models.pkg("db"), app.models.pkg("data"))
-
-    collections = [DataCollection(schema.classes[cname]) for cname in api_collections]
-
-    # generate API
-    make_python_api(app, collections)
-
-    # generate services
-    make_python_service_structure(app, collections)
+    if language == Language.Python:
+        # generate application configuration
+        make_config(app)
+
+        # generate models from schema
+        # TODO: fix me, this is a hack to make the code work for referenced classes
+        referenced_classes = {
+            path.rsplit(".", 1)[1]: (parts := path.rsplit(".", 1))[0]
+            + ".data."
+            + parts[1]
+            for path in referenced_schema
+        }
+        make_python_data_model(schema, app.models.pkg("data"), referenced_classes)
+        referenced_classes = {
+            path.rsplit(".", 1)[1]: (parts := path.rsplit(".", 1))[0]
+            + ".db."
+            + parts[1]
+            for path in referenced_schema
+        }
+        make_python_relational_model(
+            schema,
+            app.models.pkg("db"),
+            app.models.pkg("data"),
+            referenced_classes,
+        )
+
+        collections = [
+            DataCollection(schema.classes[cname]) for cname in api_collections
+        ]
+
+        # generate API
+        make_python_api(app, collections)
+
+        # generate services
+        make_python_service_structure(app, collections)
+    elif language == Language.Typescript:
+        make_typescript_data_model(schema, app.models)
 
     return app
 

sera/make/make_python_api.py

@@ -27,41 +27,43 @@ def make_python_api(app: App, collections: Sequence[DataCollection]):
         controllers.append(make_python_create_api(collection, route))
         controllers.append(make_python_update_api(collection, route))
 
-        program = Program()
-        program.import_("__future__.annotations", True)
-        program.import_("litestar.Router", True)
-        for get_route, get_route_fn in controllers:
-            program.import_(get_route.path + "." + get_route_fn, True)
-
-        program.root(
-            stmt.LineBreak(),
-            lambda ast: ast.assign(
-                DeferredVar.simple("router"),
-                expr.ExprFuncCall(
-                    expr.ExprIdent("Router"),
-                    [
-                        PredefinedFn.keyword_assignment(
-                            "path",
-                            expr.ExprConstant(
-                                f"/{to_snake_case(collection.name).replace('_', '-')}"
+        routemod = route.module("route")
+        if not routemod.exists():
+            program = Program()
+            program.import_("__future__.annotations", True)
+            program.import_("litestar.Router", True)
+            for get_route, get_route_fn in controllers:
+                program.import_(get_route.path + "." + get_route_fn, True)
+
+            program.root(
+                stmt.LineBreak(),
+                lambda ast: ast.assign(
+                    DeferredVar.simple("router"),
+                    expr.ExprFuncCall(
+                        expr.ExprIdent("Router"),
+                        [
+                            PredefinedFn.keyword_assignment(
+                                "path",
+                                expr.ExprConstant(
+                                    f"/api/{to_snake_case(collection.name).replace('_', '-')}"
+                                ),
                             ),
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "route_handlers",
-                            PredefinedFn.list(
-                                [
-                                    expr.ExprIdent(get_route_fn)
-                                    for get_route, get_route_fn in controllers
-                                ]
+                            PredefinedFn.keyword_assignment(
+                                "route_handlers",
+                                PredefinedFn.list(
+                                    [
+                                        expr.ExprIdent(get_route_fn)
+                                        for get_route, get_route_fn in controllers
+                                    ]
+                                ),
                             ),
-                        ),
-                    ],
+                        ],
+                    ),
                 ),
-            ),
-        )
+            )
 
-        route.module("route").write(program)
-        routes.append(route.module("route"))
+            routemod.write(program)
+        routes.append(routemod)
 
     # make the main entry point
     make_main(app.api, routes)
@@ -153,7 +155,7 @@ def make_python_get_api(
     program.import_(app.models.db.path + ".base.get_session", True)
     program.import_("litestar.di.Provide", True)
     program.import_("sqlalchemy.orm.Session", True)
-    program.import_(app.config.path + ".ROUTER_DEBUG", True)
+    program.import_(app.config.path + ".API_DEBUG", True)
     program.import_(
         f"{app.api.path}.dependencies.{collection.get_pymodule_name()}.{ServiceNameDep}",
         True,
@@ -224,19 +226,19 @@ def make_python_get_api(
                 DeferredVar.simple(
                     "sorted_by",
                     expr.ExprIdent(
-                        "Annotated[list[str], Parameter(description=\"list of field names to sort by, prefix a field with '-' to sort that field in descending order\")]"
+                        "Annotated[list[str], Parameter(default=tuple(), description=\"list of field names to sort by, prefix a field with '-' to sort that field in descending order\")]"
                     ),
                 ),
                 DeferredVar.simple(
                     "group_by",
                     expr.ExprIdent(
-                        'Annotated[list[str], Parameter(description="list of field names to group by")]'
+                        'Annotated[list[str], Parameter(default=tuple(), description="list of field names to group by")]'
                     ),
                 ),
                 DeferredVar.simple(
                     "fields",
                     expr.ExprIdent(
-                        'Annotated[list[str], Parameter(description="list of field names to include in the results")]'
+                        'Annotated[list[str], Parameter(default=tuple(), description="list of field names to include in the results")]'
                     ),
                 ),
                 DeferredVar.simple(
@@ -252,7 +254,7 @@ def make_python_get_api(
                     expr.ExprIdent("Session"),
                 ),
             ],
-            return_type=expr.ExprIdent(f"Sequence[{collection.name}]"),
+            return_type=expr.ExprIdent(f"dict"),
             is_async=True,
         )(
             stmt.SingleExprStatement(
@@ -267,7 +269,7 @@ def make_python_get_api(
                         expr.ExprIdent("QUERYABLE_FIELDS"),
                         PredefinedFn.keyword_assignment(
                             "debug",
-                            expr.ExprIdent("ROUTER_DEBUG"),
+                            expr.ExprIdent("API_DEBUG"),
                         ),
                     ],
                 ),
@@ -303,14 +305,31 @@ def make_python_get_api(
                 ),
             ),
             lambda ast13: ast13.return_(
-                PredefinedFn.map_list(
-                    expr.ExprIdent("result"),
-                    lambda item: expr.ExprFuncCall(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent(collection.name), expr.ExprIdent("from_db")
+                PredefinedFn.dict(
+                    [
+                        (
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent(collection.name),
+                                expr.ExprIdent("__name__"),
+                            ),
+                            PredefinedFn.map_list(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("result"), expr.ExprIdent("records")
+                                ),
+                                lambda item: expr.ExprMethodCall(
+                                    expr.ExprIdent(collection.name),
+                                    "from_db",
+                                    [item],
+                                ),
+                            ),
                         ),
-                        [item],
-                    ),
+                        (
+                            expr.ExprConstant("total"),
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("result"), expr.ExprIdent("total")
+                            ),
+                        ),
+                    ]
                 )
             ),
         ),