sera-2 1.12.3__py3-none-any.whl → 1.12.6__py3-none-any.whl

sera/libs/base_orm.py

@@ -4,10 +4,12 @@ from typing import Optional
 
 import orjson
 from msgspec.json import decode, encode
-from sera.typing import UNSET
 from sqlalchemy import LargeBinary, TypeDecorator
 from sqlalchemy import create_engine as sqlalchemy_create_engine
 from sqlalchemy import update
+from sqlalchemy.ext.asyncio import create_async_engine as sqlalchemy_create_async_engine
+
+from sera.typing import UNSET
 
 
 class BaseORM:
@@ -104,11 +106,27 @@ class DictDataclassType(TypeDecorator):
 def create_engine(
     dbconn: str,
     connect_args: Optional[dict] = None,
-    debug: bool = False,
+    echo: bool = False,
+):
+    if dbconn.startswith("sqlite"):
+        connect_args = {"check_same_thread": False}
+    else:
+        connect_args = {}
+    engine = sqlalchemy_create_engine(dbconn, connect_args=connect_args, echo=echo)
+    return engine
+
+
+def create_async_engine(
+    dbconn: str,
+    connect_args: Optional[dict] = None,
+    echo: bool = False,
 ):
     if dbconn.startswith("sqlite"):
         connect_args = {"check_same_thread": False}
     else:
         connect_args = {}
-    engine = sqlalchemy_create_engine(dbconn, connect_args=connect_args, echo=debug)
+
+    engine = sqlalchemy_create_async_engine(
+        dbconn, connect_args=connect_args, echo=echo
+    )
     return engine

sera/libs/base_service.py

@@ -4,8 +4,11 @@ from enum import Enum
 from math import dist
 from typing import Annotated, Any, Generic, NamedTuple, Optional, Sequence, TypeVar
 
-from sqlalchemy import Result, Select, exists, func, select
-from sqlalchemy.orm import Session, load_only
+from litestar.exceptions import HTTPException
+from sqlalchemy import Result, Select, delete, exists, func, select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import load_only
 
 from sera.libs.base_orm import BaseORM
 from sera.misc import assert_not_null
@@ -41,7 +44,7 @@ class QueryResult(NamedTuple, Generic[R]):
     total: int
 
 
-class BaseService(Generic[ID, R]):
+class BaseAsyncService(Generic[ID, R]):
 
     instance = None
 
@@ -51,7 +54,7 @@ class BaseService(Generic[ID, R]):
         self.id_prop = assert_not_null(cls.get_id_property())
 
         self._cls_id_prop = getattr(self.orm_cls, self.id_prop.name)
-        self.is_id_auto_increment = self.id_prop.db.is_auto_increment
+        self.is_id_auto_increment = assert_not_null(self.id_prop.db).is_auto_increment
 
     @classmethod
     def get_instance(cls):
@@ -59,10 +62,10 @@ class BaseService(Generic[ID, R]):
         if cls.instance is None:
             # assume that the subclass overrides the __init__ method
             # so that we don't need to pass the class and orm_cls
-            cls.instance = cls()
+            cls.instance = cls()  # type: ignore[call-arg]
         return cls.instance
 
-    def get(
+    async def get(
         self,
         query: Query,
         limit: int,
@@ -71,7 +74,7 @@ class BaseService(Generic[ID, R]):
         sorted_by: list[str],
         group_by: list[str],
         fields: list[str],
-        session: Session,
+        session: AsyncSession,
     ) -> QueryResult[R]:
         """Retrieving records matched a query.
 
@@ -103,35 +106,37 @@ class BaseService(Generic[ID, R]):
 
         cq = select(func.count()).select_from(q.subquery())
         rq = q.limit(limit).offset(offset)
-        records = self._process_result(session.execute(rq)).scalars().all()
-        total = session.execute(cq).scalar_one()
+        records = self._process_result(await session.execute(rq)).scalars().all()
+        total = (await session.execute(cq)).scalar_one()
         return QueryResult(records, total)
 
-    def get_by_id(self, id: ID, session: Session) -> Optional[R]:
+    async def get_by_id(self, id: ID, session: AsyncSession) -> Optional[R]:
         """Retrieving a record by ID."""
         q = self._select().where(self._cls_id_prop == id)
-        result = self._process_result(session.execute(q)).scalar_one_or_none()
+        result = self._process_result(await session.execute(q)).scalar_one_or_none()
         return result
 
-    def has_id(self, id: ID, session: Session) -> bool:
+    async def has_id(self, id: ID, session: AsyncSession) -> bool:
         """Check whether we have a record with the given ID."""
-        q = exists().where(self._cls_id_prop == id)
-        result = session.query(q).scalar()
+        q = exists().where(self._cls_id_prop == id).select()
+        result = (await session.execute(q)).scalar()
         return bool(result)
 
-    def create(self, record: R, session: Session) -> R:
+    async def create(self, record: R, session: AsyncSession) -> R:
         """Create a new record."""
         if self.is_id_auto_increment:
             setattr(record, self.id_prop.name, None)
 
-        session.add(record)
-        session.commit()
+        try:
+            session.add(record)
+            await session.flush()
+        except IntegrityError:
+            raise HTTPException(detail="Invalid request", status_code=409)
         return record
 
-    def update(self, record: R, session: Session) -> R:
+    async def update(self, record: R, session: AsyncSession) -> R:
         """Update an existing record."""
-        session.execute(record.get_update_query())
-        session.commit()
+        await session.execute(record.get_update_query())
         return record
 
     def _select(self) -> Select:
@@ -141,3 +146,7 @@ class BaseService(Generic[ID, R]):
     def _process_result(self, result: SqlResult) -> SqlResult:
         """Process the result of a query."""
         return result
+
+    async def truncate(self, session: AsyncSession) -> None:
+        """Truncate the table."""
+        await session.execute(delete(self.orm_cls))

sera/libs/middlewares/auth.py

@@ -1,16 +1,13 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import Callable, Generator, Generic, Optional, Sequence, Type
+from typing import Awaitable, Callable, Generic, Sequence
 
 from litestar import Request
 from litestar.connection import ASGIConnection
 from litestar.exceptions import NotAuthorizedException
 from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult
 from litestar.types import ASGIApp, Method, Scopes
-from litestar.types.composite_types import Dependencies
-from sqlalchemy import select
-from sqlalchemy.orm import Session
 
 from sera.typing import T
 
@@ -26,7 +23,7 @@ class AuthMiddleware(AbstractAuthenticationMiddleware, Generic[T]):
     def __init__(
         self,
         app: ASGIApp,
-        user_handler: Callable[[str], T],
+        user_handler: Callable[[str], Awaitable[T]],
         exclude: str | list[str] | None = None,
         exclude_from_auth_key: str = "exclude_from_auth",
         exclude_http_methods: Sequence[Method] | None = None,
@@ -59,7 +56,7 @@ class AuthMiddleware(AbstractAuthenticationMiddleware, Generic[T]):
                 detail="Credentials expired",
             )
 
-        user = self.user_handler(userid)
+        user = await self.user_handler(userid)
         if user is None:
             raise NotAuthorizedException(
                 detail="User not found",

sera/make/__main__.py

@@ -49,4 +49,5 @@ def cli(
     make_app(app_dir, schema_files, api_collections, language, referenced_schema)
 
 
-app()
+if __name__ == "__main__":
+    app()

sera/make/make_python_api.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 from typing import Sequence
 
-from codegen.models import DeferredVar, PredefinedFn, Program, expr, stmt
+from codegen.models import DeferredVar, ImportHelper, PredefinedFn, Program, expr, stmt
 from loguru import logger
 
 from sera.misc import assert_not_null, to_snake_case
-from sera.models import App, DataCollection, Module, Package
+from sera.models import App, DataCollection, Module, Package, SystemControlledMode
+
+GLOBAL_IDENTS = {"AsyncSession": "sqlalchemy.ext.asyncio.AsyncSession"}
 
 
 def make_python_api(app: App, collections: Sequence[DataCollection]):
@@ -112,12 +114,13 @@ def make_python_get_api(
     app = target_pkg.app
 
     program = Program()
+    import_helper = ImportHelper(program, GLOBAL_IDENTS)
+
     program.import_("__future__.annotations", True)
     program.import_("typing.Annotated", True)
     program.import_("litestar.get", True)
     program.import_("litestar.Request", True)
     program.import_("litestar.params.Parameter", True)
-    program.import_("sqlalchemy.orm.Session", True)
     program.import_(app.config.path + ".API_DEBUG", True)
     program.import_(
         app.services.path
@@ -191,7 +194,7 @@ def make_python_get_api(
                 ),
                 DeferredVar.simple(
                     "session",
-                    expr.ExprIdent("Session"),
+                    import_helper.use("AsyncSession"),
                 ),
             ],
             return_type=expr.ExprIdent(f"dict"),
@@ -226,35 +229,37 @@ def make_python_get_api(
             ),
             lambda ast102: ast102.assign(
                 DeferredVar.simple("result"),
-                expr.ExprFuncCall(
-                    PredefinedFn.attr_getter(
-                        expr.ExprIdent("service"),
-                        expr.ExprIdent("get"),
-                    ),
-                    [
-                        expr.ExprIdent("query"),
-                        PredefinedFn.keyword_assignment(
-                            "limit", expr.ExprIdent("limit")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "offset", expr.ExprIdent("offset")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "unique", expr.ExprIdent("unique")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "sorted_by", expr.ExprIdent("sorted_by")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "group_by", expr.ExprIdent("group_by")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "fields", expr.ExprIdent("fields")
-                        ),
-                        PredefinedFn.keyword_assignment(
-                            "session", expr.ExprIdent("session")
+                expr.ExprAwait(
+                    expr.ExprFuncCall(
+                        PredefinedFn.attr_getter(
+                            expr.ExprIdent("service"),
+                            expr.ExprIdent("get"),
                         ),
-                    ],
+                        [
+                            expr.ExprIdent("query"),
+                            PredefinedFn.keyword_assignment(
+                                "limit", expr.ExprIdent("limit")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "offset", expr.ExprIdent("offset")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "unique", expr.ExprIdent("unique")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "sorted_by", expr.ExprIdent("sorted_by")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "group_by", expr.ExprIdent("group_by")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "fields", expr.ExprIdent("fields")
+                            ),
+                            PredefinedFn.keyword_assignment(
+                                "session", expr.ExprIdent("session")
+                            ),
+                        ],
+                    )
                 ),
             ),
             lambda ast103: ast103.return_(
@@ -300,14 +305,13 @@ def make_python_get_by_id_api(
     """Make an endpoint for querying resource by id"""
     app = target_pkg.app
 
-    ServiceNameDep = to_snake_case(f"{collection.name}ServiceDependency")
-
     program = Program()
+    import_helper = ImportHelper(program, GLOBAL_IDENTS)
+
     program.import_("__future__.annotations", True)
     program.import_("litestar.get", True)
     program.import_("litestar.status_codes", True)
     program.import_("litestar.exceptions.HTTPException", True)
-    program.import_("sqlalchemy.orm.Session", True)
     program.import_(
         app.services.path
         + f".{collection.get_pymodule_name()}.{collection.get_service_name()}",
@@ -342,7 +346,7 @@ def make_python_get_by_id_api(
                 ),
                 DeferredVar.simple(
                     "session",
-                    expr.ExprIdent("Session"),
+                    import_helper.use("AsyncSession"),
                 ),
             ],
             return_type=expr.ExprIdent("dict"),
@@ -361,12 +365,14 @@ def make_python_get_by_id_api(
             ),
             lambda ast11: ast11.assign(
                 DeferredVar.simple("record"),
-                expr.ExprFuncCall(
-                    expr.ExprIdent("service.get_by_id"),
-                    [
-                        expr.ExprIdent("id"),
-                        expr.ExprIdent("session"),
-                    ],
+                expr.ExprAwait(
+                    expr.ExprFuncCall(
+                        expr.ExprIdent("service.get_by_id"),
+                        [
+                            expr.ExprIdent("id"),
+                            expr.ExprIdent("session"),
+                        ],
+                    )
                 ),
             ),
             lambda ast12: ast12.if_(PredefinedFn.is_null(expr.ExprIdent("record")))(
@@ -423,14 +429,13 @@ def make_python_has_api(
     """Make an endpoint for querying resource by id"""
     app = target_pkg.app
 
-    ServiceNameDep = to_snake_case(f"{collection.name}ServiceDependency")
-
     program = Program()
+    import_helper = ImportHelper(program, GLOBAL_IDENTS)
+
     program.import_("__future__.annotations", True)
     program.import_("litestar.head", True)
     program.import_("litestar.status_codes", True)
     program.import_("litestar.exceptions.HTTPException", True)
-    program.import_("sqlalchemy.orm.Session", True)
     program.import_(
         app.services.path
         + f".{collection.get_pymodule_name()}.{collection.get_service_name()}",
@@ -465,13 +470,15 @@ def make_python_has_api(
                 ),
                 DeferredVar.simple(
                     "session",
-                    expr.ExprIdent("Session"),
+                    import_helper.use("AsyncSession"),
                 ),
             ],
             return_type=expr.ExprConstant(None),
             is_async=True,
         )(
-            stmt.SingleExprStatement(expr.ExprConstant("Retrieving record by id")),
+            stmt.SingleExprStatement(
+                expr.ExprConstant("Checking if record exists by id")
+            ),
             lambda ast100: ast100.assign(
                 DeferredVar.simple("service"),
                 expr.ExprFuncCall(
@@ -484,12 +491,14 @@ def make_python_has_api(
             ),
             lambda ast11: ast11.assign(
                 DeferredVar.simple("record_exist"),
-                expr.ExprFuncCall(
-                    expr.ExprIdent("service.has_id"),
-                    [
-                        expr.ExprIdent("id"),
-                        expr.ExprIdent("session"),
-                    ],
+                expr.ExprAwait(
+                    expr.ExprFuncCall(
+                        expr.ExprIdent("service.has_id"),
+                        [
+                            expr.ExprIdent("id"),
+                            expr.ExprIdent("session"),
+                        ],
+                    )
                 ),
             ),
             lambda ast12: ast12.if_(expr.ExprNegation(expr.ExprIdent("record_exist")))(
@@ -524,9 +533,10 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
     app = target_pkg.app
 
     program = Program()
+    import_helper = ImportHelper(program, GLOBAL_IDENTS)
+
     program.import_("__future__.annotations", True)
     program.import_("litestar.post", True)
-    program.import_("sqlalchemy.orm.Session", True)
     program.import_(
         app.services.path
         + f".{collection.get_pymodule_name()}.{collection.get_service_name()}",
@@ -540,12 +550,13 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
 
     # assuming the collection has only one class
     cls = collection.cls
-    has_system_controlled_prop = any(
-        prop.data.is_system_controlled for prop in cls.properties.values()
+    has_restricted_system_controlled_prop = any(
+        prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+        for prop in cls.properties.values()
     )
     idprop = assert_not_null(cls.get_id_property())
 
-    if has_system_controlled_prop:
+    if has_restricted_system_controlled_prop:
         program.import_("sera.libs.api_helper.SingleAutoUSCP", True)
 
     func_name = "create"
@@ -568,7 +579,7 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
                             ),
                         )
                     ]
-                    if has_system_controlled_prop
+                    if has_restricted_system_controlled_prop
                     else []
                 ),
             )
@@ -582,7 +593,7 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
                 ),
                 DeferredVar.simple(
                     "session",
-                    expr.ExprIdent("Session"),
+                    import_helper.use("AsyncSession"),
                 ),
             ],
             return_type=expr.ExprIdent(idprop.datatype.get_python_type().type),
@@ -601,13 +612,17 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
             ),
             lambda ast13: ast13.return_(
                 PredefinedFn.attr_getter(
-                    expr.ExprMethodCall(
-                        expr.ExprIdent("service"),
-                        "create",
-                        [
-                            expr.ExprMethodCall(expr.ExprIdent("data"), "to_db", []),
-                            expr.ExprIdent("session"),
-                        ],
+                    expr.ExprAwait(
+                        expr.ExprMethodCall(
+                            expr.ExprIdent("service"),
+                            "create",
+                            [
+                                expr.ExprMethodCall(
+                                    expr.ExprIdent("data"), "to_db", []
+                                ),
+                                expr.ExprIdent("session"),
+                            ],
+                        )
                     ),
                     expr.ExprIdent(idprop.name),
                 )
@@ -626,9 +641,10 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
     app = target_pkg.app
 
     program = Program()
+    import_helper = ImportHelper(program, GLOBAL_IDENTS)
+
     program.import_("__future__.annotations", True)
     program.import_("litestar.put", True)
-    program.import_("sqlalchemy.orm.Session", True)
     program.import_(
         app.services.path
         + f".{collection.get_pymodule_name()}.{collection.get_service_name()}",
@@ -645,10 +661,11 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
     id_prop = assert_not_null(cls.get_id_property())
     id_type = id_prop.datatype.get_python_type().type
 
-    has_system_controlled_prop = any(
-        prop.data.is_system_controlled for prop in cls.properties.values()
+    has_restricted_system_controlled_prop = any(
+        prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+        for prop in cls.properties.values()
     )
-    if has_system_controlled_prop:
+    if has_restricted_system_controlled_prop:
         program.import_("sera.libs.api_helper.SingleAutoUSCP", True)
 
     func_name = "update"
@@ -671,7 +688,7 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
                             ),
                         )
                     ]
-                    if has_system_controlled_prop
+                    if has_restricted_system_controlled_prop
                     else []
                 ),
             )
@@ -689,7 +706,7 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
                 ),
                 DeferredVar.simple(
                     "session",
-                    expr.ExprIdent("Session"),
+                    import_helper.use("AsyncSession"),
                 ),
             ],
             return_type=expr.ExprIdent(id_prop.datatype.get_python_type().type),
@@ -715,13 +732,17 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
             ),
             lambda ast13: ast13.return_(
                 PredefinedFn.attr_getter(
-                    expr.ExprMethodCall(
-                        expr.ExprIdent("service"),
-                        "update",
-                        [
-                            expr.ExprMethodCall(expr.ExprIdent("data"), "to_db", []),
-                            expr.ExprIdent("session"),
-                        ],
+                    expr.ExprAwait(
+                        expr.ExprMethodCall(
+                            expr.ExprIdent("service"),
+                            "update",
+                            [
+                                expr.ExprMethodCall(
+                                    expr.ExprIdent("data"), "to_db", []
+                                ),
+                                expr.ExprIdent("session"),
+                            ],
+                        )
                     ),
                     expr.ExprIdent(id_prop.name),
                 )

sera/make/make_python_model.py

@@ -1,9 +1,16 @@
 from __future__ import annotations
 
-from operator import is_
 from typing import Callable, Optional, Sequence
 
-from codegen.models import AST, DeferredVar, PredefinedFn, Program, expr, stmt
+from codegen.models import (
+    AST,
+    DeferredVar,
+    ImportHelper,
+    PredefinedFn,
+    Program,
+    expr,
+    stmt,
+)
 
 from sera.misc import (
     assert_isinstance,
@@ -20,6 +27,7 @@ from sera.models import (
     PyTypeWithDep,
     Schema,
 )
+from sera.models._property import SystemControlledMode
 from sera.typing import ObjectPath
 
 
@@ -211,10 +219,19 @@ def make_python_data_model(
                 alias=f"{cls.name}DB",
             )
 
-        has_system_controlled = any(
-            prop.data.is_system_controlled for prop in cls.properties.values()
+        ident_manager = ImportHelper(
+            program,
+            {
+                "UNSET": "sera.typing.UNSET",
+            },
+        )
+
+        # property that normal users cannot set, but super users can
+        has_restricted_system_controlled = any(
+            prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+            for prop in cls.properties.values()
         )
-        if has_system_controlled:
+        if has_restricted_system_controlled:
             program.import_("typing.TypedDict", True)
             program.root(
                 stmt.LineBreak(),
@@ -236,6 +253,7 @@ def make_python_data_model(
                         )
                         for prop in cls.properties.values()
                         if prop.data.is_system_controlled
+                        == SystemControlledMode.RESTRICTED
                     ],
                 ),
             )
@@ -246,11 +264,10 @@ def make_python_data_model(
             [expr.ExprIdent("msgspec.Struct"), expr.ExprIdent("kw_only=True")],
         )
         for prop in cls.properties.values():
-            # this is a create object, so users can create private field
-            # hence, we do not check for prop.is_private -- however, this field can be omitted
-            # during update, so we need to mark it as optional
-            # if prop.data.is_private:
-            #     continue
+            # a field that is fully controlled by the system (e.g., cached or derived fields)
+            # aren't allowed to be set by the users, so we skip them
+            if prop.data.is_system_controlled == SystemControlledMode.AUTO:
+                continue
 
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
@@ -272,14 +289,20 @@ def make_python_data_model(
                     else:
                         raise NotImplementedError(prop.data.constraints)
 
-                if prop.data.is_private:
+                if (
+                    prop.data.is_private
+                    or prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+                ):
                     program.import_("typing.Union", True)
                     program.import_("sera.typing.UnsetType", True)
                     program.import_("sera.typing.UNSET", True)
                     pytype_type = f"Union[{pytype_type}, UnsetType]"
 
                 prop_default_value = None
-                if prop.data.is_private:
+                if (
+                    prop.data.is_private
+                    or prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+                ):
                     prop_default_value = expr.ExprIdent("UNSET")
                 elif prop.default_value is not None:
                     prop_default_value = expr.ExprConstant(prop.default_value)
@@ -321,25 +344,28 @@ def make_python_data_model(
                 elif prop.is_optional:
                     pytype = pytype.as_optional_type()
 
+                pytype_type = pytype.type
+                prop_default_value = None
+                if prop.data.is_system_controlled == SystemControlledMode.RESTRICTED:
+                    program.import_("typing.Union", True)
+                    program.import_("sera.typing.UnsetType", True)
+                    program.import_("sera.typing.UNSET", True)
+                    pytype_type = f"Union[{pytype_type}, UnsetType]"
+                    prop_default_value = expr.ExprIdent("UNSET")
+
                 for dep in pytype.deps:
                     program.import_(dep, True)
 
-                cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
-
-        # has_to_db = True
-        # if any(prop for prop in cls.properties.values() if isinstance(prop, ObjectProperty) and prop.cardinality == Cardinality.MANY_TO_MANY):
-        #     # if the class has many-to-many relationship, we need to
+                cls_ast(
+                    stmt.DefClassVarStatement(
+                        prop.name, pytype_type, prop_default_value
+                    )
+                )
 
-        if has_system_controlled:
+        if has_restricted_system_controlled:
             program.import_("typing.Optional", True)
+            program.import_("sera.typing.is_set", True)
             cls_ast(
-                stmt.LineBreak(),
-                stmt.Comment(
-                    "_verified is a special marker to indicate whether the data is updated by the system."
-                ),
-                stmt.DefClassVarStatement(
-                    "_verified", "bool", expr.ExprConstant(False)
-                ),
                 stmt.LineBreak(),
                 lambda ast: ast.func(
                     "__post_init__",
@@ -347,12 +373,17 @@ def make_python_data_model(
                         DeferredVar.simple("self"),
                     ],
                 )(
-                    stmt.AssignStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
-                        ),
-                        expr.ExprConstant(False),
-                    )
+                    *[
+                        stmt.AssignStatement(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("self"), expr.ExprIdent(prop.name)
+                            ),
+                            expr.ExprIdent("UNSET"),
+                        )
+                        for prop in cls.properties.values()
+                        if prop.data.is_system_controlled
+                        == SystemControlledMode.RESTRICTED
+                    ]
                 ),
                 stmt.LineBreak(),
                 lambda ast: ast.func(
@@ -381,14 +412,9 @@ def make_python_data_model(
                             )
                             for prop in cls.properties.values()
                             if prop.data.is_system_controlled
+                            == SystemControlledMode.RESTRICTED
                         ]
                     ),
-                    stmt.AssignStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
-                        ),
-                        expr.ExprConstant(True),
-                    ),
                 ),
             )
 
@@ -405,14 +431,27 @@ def make_python_data_model(
             )(
                 (
                     stmt.AssertionStatement(
-                        PredefinedFn.attr_getter(
-                            expr.ExprIdent("self"), expr.ExprIdent("_verified")
+                        expr.ExprLogicalAnd(
+                            [
+                                expr.ExprFuncCall(
+                                    expr.ExprIdent("is_set"),
+                                    [
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprIdent("self"),
+                                            expr.ExprIdent(prop.name),
+                                        )
+                                    ],
+                                )
+                                for prop in cls.properties.values()
+                                if prop.data.is_system_controlled
+                                == SystemControlledMode.RESTRICTED
+                            ]
                         ),
                         expr.ExprConstant(
                             "The model data must be verified before converting to db model"
                         ),
                     )
-                    if has_system_controlled
+                    if has_restricted_system_controlled
                     else None
                 ),
                 lambda ast10: ast10.return_(
@@ -421,8 +460,13 @@ def make_python_data_model(
                             f"{cls.name}DB" if cls.db is not None else cls.name
                         ),
                         [
-                            to_db_type_conversion(
-                                program, expr.ExprIdent("self"), cls, prop
+                            (
+                                to_db_type_conversion(
+                                    program, expr.ExprIdent("self"), cls, prop
+                                )
+                                if prop.data.is_system_controlled
+                                != SystemControlledMode.AUTO
+                                else ident_manager.use("UNSET")
                             )
                             for prop in cls.properties.values()
                         ],
@@ -623,8 +667,11 @@ def make_python_relational_model(
         program.import_("__future__.annotations", True)
         program.import_("sera.libs.base_orm.BaseORM", True)
         program.import_("sera.libs.base_orm.create_engine", True)
+        program.import_("sera.libs.base_orm.create_async_engine", True)
         program.import_("sqlalchemy.orm.DeclarativeBase", True)
         program.import_("sqlalchemy.orm.Session", True)
+        program.import_("sqlalchemy.ext.asyncio.AsyncSession", True)
+        program.import_("sqlalchemy.text", True)
 
         # assume configuration for the app at the top level
         program.import_(f"{app.config.path}.DB_CONNECTION", True)
@@ -673,14 +720,22 @@ def make_python_relational_model(
 
         program.root.linebreak()
         program.root.assign(
-            DeferredVar("engine", force_name="engine"),
+            DeferredVar.simple("engine"),
             expr.ExprFuncCall(
                 expr.ExprIdent("create_engine"),
                 [
                     expr.ExprIdent("DB_CONNECTION"),
-                    PredefinedFn.keyword_assignment(
-                        "debug", expr.ExprIdent("DB_DEBUG")
-                    ),
+                    PredefinedFn.keyword_assignment("echo", expr.ExprIdent("DB_DEBUG")),
+                ],
+            ),
+        )
+        program.root.assign(
+            DeferredVar.simple("async_engine"),
+            expr.ExprFuncCall(
+                expr.ExprIdent("create_async_engine"),
+                [
+                    expr.ExprIdent("DB_CONNECTION"),
+                    PredefinedFn.keyword_assignment("echo", expr.ExprIdent("DB_DEBUG")),
                 ],
             ),
         )
@@ -691,17 +746,96 @@ def make_python_relational_model(
         )
 
         program.root.linebreak()
-        program.root.func("async_get_session", [], is_async=True)(
-            lambda ast00: ast00.python_stmt("with Session(engine) as session:")(
-                lambda ast01: ast01.python_stmt("yield session")
+        program.root.func("get_async_session", [], is_async=True)(
+            lambda ast: ast.python_stmt(
+                "async with AsyncSession(async_engine, expire_on_commit=False) as session:"
+            )(
+                lambda ast_l1: ast_l1.try_()(stmt.PythonStatement("yield session")),
+                lambda ast_l1: ast_l1.catch()(
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"),
+                                    expr.ExprIdent("rollback"),
+                                ),
+                                [],
+                            )
+                        )
+                    ),
+                    stmt.PythonStatement("raise"),
+                ),
+                lambda ast_l1: ast_l1.else_()(
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"), expr.ExprIdent("execute")
+                                ),
+                                [
+                                    expr.ExprFuncCall(
+                                        expr.ExprIdent("text"),
+                                        [expr.ExprConstant("RESET ROLE;")],
+                                    )
+                                ],
+                            )
+                        )
+                    ),
+                    stmt.SingleExprStatement(
+                        expr.ExprAwait(
+                            expr.ExprFuncCall(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("session"), expr.ExprIdent("commit")
+                                ),
+                                [],
+                            )
+                        )
+                    ),
+                ),
             )
         )
 
         program.root.linebreak()
         program.root.python_stmt("@contextmanager")
         program.root.func("get_session", [])(
-            lambda ast00: ast00.python_stmt("with Session(engine) as session:")(
-                lambda ast01: ast01.python_stmt("yield session")
+            lambda ast: ast.python_stmt(
+                "with Session(engine, expire_on_commit=False) as session:"
+            )(
+                lambda ast_l1: ast_l1.try_()(stmt.PythonStatement("yield session")),
+                lambda ast_l1: ast_l1.catch()(
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("rollback")
+                            ),
+                            [],
+                        )
+                    ),
+                    stmt.PythonStatement("raise"),
+                ),
+                lambda ast_l1: ast_l1.else_()(
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("execute")
+                            ),
+                            [
+                                expr.ExprFuncCall(
+                                    expr.ExprIdent("text"),
+                                    [expr.ExprConstant("RESET ROLE;")],
+                                )
+                            ],
+                        )
+                    ),
+                    stmt.SingleExprStatement(
+                        expr.ExprFuncCall(
+                            PredefinedFn.attr_getter(
+                                expr.ExprIdent("session"), expr.ExprIdent("commit")
+                            ),
+                            [],
+                        )
+                    ),
+                ),
             )
         )
 

sera/make/make_python_services.py

@@ -4,6 +4,7 @@ from typing import Sequence
 
 from codegen.models import DeferredVar, Program, expr, stmt
 from loguru import logger
+
 from sera.misc import assert_not_null
 from sera.models import App, DataCollection, Package
 
@@ -35,13 +36,13 @@ def make_python_service(collection: DataCollection, target_pkg: Package):
         True,
     )
     program.import_(app.config.path + f".schema", True)
-    program.import_("sera.libs.base_service.BaseService", True)
+    program.import_("sera.libs.base_service.BaseAsyncService", True)
 
     program.root(
         stmt.LineBreak(),
         lambda ast00: ast00.class_(
             collection.get_service_name(),
-            [expr.ExprIdent(f"BaseService[{id_type}, {cls.name}]")],
+            [expr.ExprIdent(f"BaseAsyncService[{id_type}, {cls.name}]")],
         )(
             lambda ast01: ast01.func(
                 "__init__",

sera/models/__init__.py

@@ -5,7 +5,13 @@ from sera.models._enum import Enum
 from sera.models._module import App, Module, Package
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._parse import parse_schema
-from sera.models._property import Cardinality, DataProperty, ObjectProperty, Property
+from sera.models._property import (
+    Cardinality,
+    DataProperty,
+    ObjectProperty,
+    Property,
+    SystemControlledMode,
+)
 from sera.models._schema import Schema
 
 __all__ = [
@@ -25,4 +31,5 @@ __all__ = [
     "PyTypeWithDep",
     "TsTypeWithDep",
     "Enum",
+    "SystemControlledMode",
 ]

sera/models/_constraints.py

@@ -3,7 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal
 
-ConstraintName = Literal["phone_number", "email", "not_empty", "username", "password"]
+ConstraintName = Literal[
+    "phone_number",
+    "email",
+    "not_empty",
+    "username",
+    "password",
+    "whole_number",
+    "positive_number",
+]
 
 
 @dataclass
@@ -25,6 +33,10 @@ class Constraint:
             )
         elif self.name == "password":
             return "msgspec.Meta(min_length=8, max_length=40)"
+        elif self.name == "whole_number":
+            return "msgspec.Meta(ge=0)"
+        elif self.name == "positive_number":
+            return "msgspec.Meta(gt=0)"
 
         raise NotImplementedError()
 
@@ -43,4 +55,6 @@ predefined_constraints: dict[ConstraintName, Constraint] = {
     "not_empty": Constraint("not_empty", ()),
     "username": Constraint("username", ()),
     "password": Constraint("password", ()),
+    "whole_number": Constraint("whole_number", ()),
+    "positive_number": Constraint("positive_number", ()),
 }

sera/models/_datatype.py

@@ -164,6 +164,16 @@ predefined_datatypes = {
         tstype=TsTypeWithDep(type="number"),
         is_list=False,
     ),
+    "date": DataType(
+        pytype=PyTypeWithDep(type="date", deps=["datetime.date"]),
+        sqltype=SQLTypeWithDep(
+            type="Date",
+            mapped_pytype="date",
+            deps=["sqlalchemy.Date", "datetime.date"],
+        ),
+        tstype=TsTypeWithDep(type="string"),
+        is_list=False,
+    ),
     "datetime": DataType(
         pytype=PyTypeWithDep(type="datetime", deps=["datetime.datetime"]),
         sqltype=SQLTypeWithDep(

sera/models/_parse.py

@@ -31,6 +31,7 @@ from sera.models._property import (
     ObjectPropDBInfo,
     ObjectProperty,
     PropDataAttrs,
+    SystemControlledMode,
 )
 from sera.models._schema import Schema
 
@@ -76,7 +77,7 @@ def _parse_class_without_prop(schema: Schema, clsname: str, cls: dict) -> Class:
     return Class(
         name=clsname,
         label=_parse_multi_lingual_string(cls["label"]),
-        description=_parse_multi_lingual_string(cls["desc"]),
+        description=_parse_multi_lingual_string(cls.get("desc", "")),
         properties={},
         db=db,
     )
@@ -131,7 +132,9 @@ def _parse_property(
         constraints=[
             _parse_constraint(constraint) for constraint in _data.get("constraints", [])
         ],
-        is_system_controlled=prop.get("is_system_controlled", False),
+        is_system_controlled=SystemControlledMode(
+            _data.get("is_system_controlled", SystemControlledMode.NO.value)
+        ),
     )
 
     assert isinstance(prop, dict), prop
@@ -222,12 +225,14 @@ def _parse_datatype(schema: Schema, datatype: dict | str) -> DataType:
                 # the correct package yet.
                 pytype=PyTypeWithDep(
                     type=enum.name,
-                    dep=f"{schema.name}.models.enums.{enum.get_pymodule_name()}.{enum.name}",
+                    deps=[
+                        f"{schema.name}.models.enums.{enum.get_pymodule_name()}.{enum.name}"
+                    ],
                 ),
                 sqltype=SQLTypeWithDep(
                     type="String", mapped_pytype="str", deps=["sqlalchemy.String"]
                 ),
-                tstype=TsTypeWithDep(type=enum.name, dep="@/models/enums"),
+                tstype=TsTypeWithDep(type=enum.name, deps=["@/models/enums"]),
                 is_list=is_list,
             )
 

sera/models/_property.py

@@ -56,6 +56,19 @@ class Cardinality(str, Enum):
         ]
 
 
+class SystemControlledMode(str, Enum):
+    """Indicates if this property is controlled by the system.
+
+    There are two modes:
+    1. The system automatically sets the value, and users cannot modify it.
+    2. Users with special roles are allowed to set the value and other users cannot modify it
+    """
+
+    AUTO = "auto"
+    RESTRICTED = "restricted"
+    NO = "no"
+
+
 @dataclass(kw_only=True)
 class PropDataAttrs:
     """Storing other attributes for generating data model (upsert & public) -- this is different from a db model"""
@@ -72,7 +85,7 @@ class PropDataAttrs:
     constraints: list[Constraint] = field(default_factory=list)
 
     # whether this property is controlled by the system or not
-    is_system_controlled: bool = False
+    is_system_controlled: SystemControlledMode = SystemControlledMode.NO
 
 
 @dataclass(kw_only=True)

{sera_2-1.12.3.dist-info → sera_2-1.12.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.12.3
+Version: 1.12.6
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -9,13 +9,13 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (>=25.1.0,<26.0.0)
-Requires-Dist: codegen-2 (>=2.10.0,<3.0.0)
+Requires-Dist: codegen-2 (>=2.11.0,<3.0.0)
 Requires-Dist: isort (>=6.0.1,<7.0.0)
 Requires-Dist: litestar (>=2.15.1,<3.0.0)
 Requires-Dist: loguru (>=0.7.0,<0.8.0)
 Requires-Dist: msgspec (>=0.19.0,<0.20.0)
 Requires-Dist: serde2 (>=1.9.0,<2.0.0)
-Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0)
+Requires-Dist: sqlalchemy[asyncio] (>=2.0.41,<3.0.0)
 Requires-Dist: typer (>=0.12.3,<0.13.0)
 Project-URL: Repository, https://github.com/binh-vu/sera
 Description-Content-Type: text/markdown

{sera_2-1.12.3.dist-info → sera_2-1.12.6.dist-info}/RECORD

@@ -2,36 +2,36 @@ sera/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/constants.py,sha256=mzAaMyIx8TJK0-RYYJ5I24C4s0Uvj26OLMJmBo0pxHI,123
 sera/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/libs/api_helper.py,sha256=47y1kcwk3Xd2ZEMnUj_0OwCuUmgwOs5kYrE95BDVUn4,5411
-sera/libs/base_orm.py,sha256=dyh0OT2sbHku5qPJXvRzYAHRTSXvvbQaS-Qwg65Bw04,2918
-sera/libs/base_service.py,sha256=8uKMaIicLc8LbN5vyaK9dGWoCLf_wuaaOw9ooSiqSWM,4614
+sera/libs/base_orm.py,sha256=5hOH_diUeaABm3cpE2-9u50VRqG1QW2osPQnvVHIhIA,3365
+sera/libs/base_service.py,sha256=AX1WoTHte6Z_birkkfagkNE6BrCLTlTjQE4jEsKEaAY,5152
 sera/libs/dag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/libs/dag/_dag.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sera/libs/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sera/libs/middlewares/auth.py,sha256=aH2fJshQpJT_dw3lUr67doZ8zdf90XyakdY35qZ1iZs,2443
+sera/libs/middlewares/auth.py,sha256=r6aix1ZBwxMd1Jv5hMCTB8a_gFOJQ6egvxIrf3DWEOs,2323
 sera/libs/middlewares/uscp.py,sha256=H5umW8iEQSCdb_MJ5Im49kxg1E7TpxSg1p2_2A5zI1U,2600
 sera/make/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sera/make/__main__.py,sha256=G5O7s6135-708honwqMFn2yPTs06WbGQTHpupID0eZ4,1417
+sera/make/__main__.py,sha256=bt-gDF8E026OWc2zqr9_a3paMOiDkFd3ybWn8ltL2g0,1448
 sera/make/make_app.py,sha256=n9NtW73O3s_5Q31VHIRmnd-jEIcpDO7ksAsOdovde2s,5999
-sera/make/make_python_api.py,sha256=CM0NTcSUMgRagscvpZwrbI_PR9d4CsgZ2xUVM0rCVVg,26031
-sera/make/make_python_model.py,sha256=ldaDnuwudkq81w2hwKZIuRqFnqhxOAaIT_VhYandXG4,46128
-sera/make/make_python_services.py,sha256=RsinYZdfkrTlTn9CT50VgqGs9w6IZawsJx-KEmqfnEY,2062
+sera/make/make_python_api.py,sha256=sf-J5Pt1LTyM_H-SgXSAvKjEMDrRA6WnDpgDPbJG360,26896
+sera/make/make_python_model.py,sha256=XWoNmfVNfdzF3lwEaItPZjo27ibqL9yjHA3a0vrHsnA,51708
+sera/make/make_python_services.py,sha256=0ZpWLwQ7Nwfn8BXAikAB4JRpNknpSJyJgY5b1cjtxV4,2073
 sera/make/make_typescript_model.py,sha256=ugDdSTw_1ayHLuL--92RQ8hf_D-dpJtnvmUZNxcwcDs,63687
 sera/misc/__init__.py,sha256=Dh4uDq0D4N53h3zhvmwfa5a0TPVRSUvLzb0hkFuPirk,411
 sera/misc/_formatter.py,sha256=aCGYL08l8f3aLODHxSocxBBwkRYEo3K1QzCDEn3suj0,1685
 sera/misc/_utils.py,sha256=V5g4oLGHOhUCR75Kkcn1w01pAvGvaepK-T8Z3pIgHjI,1450
-sera/models/__init__.py,sha256=vJC5Kzo_N7wd16ocNPy1VvAZDGNiWeiAhWJ4ihATKvA,780
+sera/models/__init__.py,sha256=VcC7HvqXuYrkgXwzs2vOH6LJPpzFBkeDvYVNrd3P-6E,855
 sera/models/_class.py,sha256=Wf0e8x6-szG9TzoFkAlqj7_dG0SCICMBw_333n3paxk,2514
 sera/models/_collection.py,sha256=ZnQEriKC4X88Zz48Kn1AVZKH-1_l8OgWa-zf2kcQOOE,1414
-sera/models/_constraints.py,sha256=L6QwKL3hRJ5DvvIB4JNgLoyvTKbE9FrpYRzezM4CweE,1484
-sera/models/_datatype.py,sha256=RDn0lDl_b0O_PwRqobcD1O903owEAEoMzRf4dyRcgBk,6819
+sera/models/_constraints.py,sha256=PsSOX94b9-73wZTcUif9KTzV9uTfoF0WN87g4GZXQmU,1827
+sera/models/_datatype.py,sha256=y5kfim0G3gLhnGjiokFBr8leU1Y6as_Vw7oK-caOo68,7140
 sera/models/_default.py,sha256=ABggW6qdPR4ZDqIPJdJ0GCGQ-7kfsfZmQ_DchgZEa-I,137
 sera/models/_enum.py,sha256=sy0q7E646F-APsqrVQ52r1fAQ_DCAeaNq5YM5QN3zIk,2070
 sera/models/_module.py,sha256=8QRSCubZmdDP9rL58rGAS6X5VCrkc1ZHvuMu1I1KrWk,5043
 sera/models/_multi_lingual_string.py,sha256=JETN6k00VH4wrA4w5vAHMEJV8fp3SY9bJebskFTjQLA,1186
-sera/models/_parse.py,sha256=uw6fvvh1ucGqE2jFTCCr-e6_qMfZfSVpaPolNxmrHww,9897
-sera/models/_property.py,sha256=SJSm5fZJimd2rQuL4UH_aZuNyp9v7x64xMbEVbtYx8Q,5633
+sera/models/_parse.py,sha256=q_YZ7PrHWIN85_WW-fPP7-2gLXlGWM2-EIdbYXuG7Xg,10052
+sera/models/_property.py,sha256=4y9F58D6DoX25-6aWPBRiE72nCPQy0KWlGNDTZXSV-8,6038
 sera/models/_schema.py,sha256=r-Gqg9Lb_wR3UrbNvfXXgt_qs5bts0t2Ve7aquuF_OI,1155
 sera/typing.py,sha256=Q4QMfbtfrCjC9tFfsZPhsAnbNX4lm4NHQ9lmjNXYdV0,772
-sera_2-1.12.3.dist-info/METADATA,sha256=5KV9Z9cwjWA1UZKqo9iCrj0XRwL54xS7JmRrGAc5S7s,858
-sera_2-1.12.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-sera_2-1.12.3.dist-info/RECORD,,
+sera_2-1.12.6.dist-info/METADATA,sha256=MlOqmC3MJASvXLuS8k0KO5UE8325j9Ff53RArvIn5Wo,867
+sera_2-1.12.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+sera_2-1.12.6.dist-info/RECORD,,