sera-2 1.21.2__py3-none-any.whl → 1.23.0__py3-none-any.whl

sera/make/make_python_model.py

@@ -883,6 +883,35 @@ def make_python_data_model(
                 ),
             )
 
+    def make_data_schema_export():
+        program = Program()
+        program.import_("__future__.annotations", True)
+
+        expose_vars = [expr.ExprConstant(cls.name) for cls in schema.classes.values()]
+        expose_vars.append(expr.ExprConstant("dataschema"))
+
+        output = []
+        for cls in schema.classes.values():
+            program.import_(
+                f"{target_pkg.path}.{cls.get_pymodule_name()}.{cls.name}",
+                True,
+            )
+            output.append((expr.ExprConstant(cls.name), expr.ExprIdent(cls.name)))
+
+        program.root(
+            stmt.LineBreak(),
+            lambda ast: ast.assign(
+                DeferredVar.simple("dataschema"), PredefinedFn.dict(output)
+            ),
+            stmt.LineBreak(),
+            lambda ast: ast.assign(
+                DeferredVar.simple("__all__"),
+                PredefinedFn.list(expose_vars),
+            ),
+        )
+
+        target_pkg.parent().module("data_schema").write(program)
+
     for cls in schema.topological_sort():
         if cls.name in reference_classes:
             continue
@@ -895,6 +924,8 @@ def make_python_data_model(
         make_normal(program, cls)
         target_pkg.module(cls.get_pymodule_name()).write(program)
 
+    make_data_schema_export()
+
 
 def make_python_relational_model(
     schema: Schema,
@@ -1098,6 +1129,66 @@ def make_python_relational_model(
 
         target_pkg.module("base").write(program)
 
+    def make_db_schema_export():
+        program = Program()
+        program.import_("__future__.annotations", True)
+
+        expose_vars = [
+            expr.ExprConstant(cls.name)
+            for cls in schema.classes.values()
+            if cls.db is not None
+        ]
+        expose_vars.append(expr.ExprConstant("dbschema"))
+
+        for name in ["engine", "async_engine", "get_session", "get_async_session"]:
+            program.import_(f"{target_pkg.path}.base.{name}", True)
+            expose_vars.append(expr.ExprConstant(name))
+
+        output = []
+        for cls in schema.classes.values():
+            if cls.db is None:
+                continue
+            program.import_(
+                f"{target_pkg.path}.{cls.get_pymodule_name()}.{cls.name}",
+                True,
+            )
+            output.append((expr.ExprConstant(cls.name), expr.ExprIdent(cls.name)))
+
+            # if there is a MANY-TO-MANY relationship, we need to add an association table as well
+            for prop in cls.properties.values():
+                if (
+                    not isinstance(prop, ObjectProperty)
+                    or prop.target.db is None
+                    or prop.cardinality != Cardinality.MANY_TO_MANY
+                ):
+                    continue
+
+                program.import_(
+                    f"{target_pkg.path}.{to_snake_case(cls.name + prop.target.name)}.{cls.name}{prop.target.name}",
+                    True,
+                )
+                output.append(
+                    (
+                        expr.ExprConstant(f"{cls.name}{prop.target.name}"),
+                        expr.ExprIdent(f"{cls.name}{prop.target.name}"),
+                    )
+                )
+                expose_vars.append(expr.ExprConstant(f"{cls.name}{prop.target.name}"))
+
+        program.root(
+            stmt.LineBreak(),
+            lambda ast: ast.assign(
+                DeferredVar.simple("dbschema"), PredefinedFn.dict(output)
+            ),
+            stmt.LineBreak(),
+            lambda ast: ast.assign(
+                DeferredVar.simple("__all__"),
+                PredefinedFn.list(expose_vars),
+            ),
+        )
+
+        target_pkg.module("__init__").write(program)
+
     def make_orm(cls: Class):
         if cls.db is None or cls.name in reference_classes:
             # skip classes that are not stored in the database
@@ -1242,10 +1333,44 @@ def make_python_relational_model(
                     expr.ExprIdent("mapped_column"), propvalargs
                 )
                 cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
+
+                if prop.db.foreign_key is not None:
+                    # add a relationship property for foreign key primary key so that we can do eager join in SQLAlchemy
+                    program.import_("sqlalchemy.orm.relationship", True)
+                    if prop.db.foreign_key.name != cls.name:
+                        ident_manager.python_import_for_hint(
+                            target_pkg.path
+                            + f".{prop.db.foreign_key.get_pymodule_name()}.{prop.db.foreign_key.name}",
+                            True,
+                        )
+                    cls_ast(
+                        stmt.DefClassVarStatement(
+                            propname + "_relobj",
+                            f"Mapped[{prop.db.foreign_key.name}]",
+                            expr.ExprFuncCall(
+                                expr.ExprIdent("relationship"),
+                                [
+                                    PredefinedFn.keyword_assignment(
+                                        "lazy",
+                                        expr.ExprConstant("raise_on_sql"),
+                                    ),
+                                    PredefinedFn.keyword_assignment(
+                                        "foreign_keys",
+                                        expr.ExprIdent(propname),
+                                    ),
+                                    PredefinedFn.keyword_assignment(
+                                        "init",
+                                        expr.ExprConstant(False),
+                                    ),
+                                ],
+                            ),
+                        )
+                    )
             else:
                 assert isinstance(prop, ObjectProperty)
                 make_python_relational_object_property(
                     program=program,
+                    ident_manager=ident_manager,
                     target_pkg=target_pkg,
                     target_data_pkg=target_data_pkg,
                     cls_ast=cls_ast,
@@ -1267,9 +1392,13 @@ def make_python_relational_model(
     )
     make_base(custom_types)
 
+    # export the db classes in the __init__ file
+    make_db_schema_export()
+
 
 def make_python_relational_object_property(
     program: Program,
+    ident_manager: ImportHelper,
     target_pkg: Package,
     target_data_pkg: Package,
     cls_ast: AST,
@@ -1291,6 +1420,14 @@ def make_python_relational_object_property(
         if prop.cardinality.is_star_to_many():
             raise NotImplementedError((cls.name, prop.name))
 
+        program.import_("sqlalchemy.orm.relationship", True)
+        if prop.target.name != cls.name:
+            ident_manager.python_import_for_hint(
+                target_pkg.path
+                + f".{prop.target.get_pymodule_name()}.{prop.target.name}",
+                True,
+            )
+
         # we store this class in the database
         propname = f"{prop.name}_id"
         idprop = prop.target.get_id_property()
@@ -1329,7 +1466,30 @@ def make_python_relational_object_property(
             ],
         )
 
-        cls_ast(stmt.DefClassVarStatement(propname, proptype, propval))
+        cls_ast(
+            stmt.DefClassVarStatement(propname, proptype, propval),
+            stmt.DefClassVarStatement(
+                prop.name,
+                f"Mapped[{prop.target.name}]",
+                expr.ExprFuncCall(
+                    expr.ExprIdent("relationship"),
+                    [
+                        PredefinedFn.keyword_assignment(
+                            "lazy",
+                            expr.ExprConstant("raise_on_sql"),
+                        ),
+                        PredefinedFn.keyword_assignment(
+                            "foreign_keys",
+                            expr.ExprIdent(propname),
+                        ),
+                        PredefinedFn.keyword_assignment(
+                            "init",
+                            expr.ExprConstant(False),
+                        ),
+                    ],
+                ),
+            ),
+        )
         return
 
     # if the target class is not in the database,
@@ -1352,16 +1512,16 @@ def make_python_relational_object_property(
         program.import_("sqlalchemy.orm.composite", True)
         propvalargs: list[expr.Expr] = [expr.ExprIdent(prop.target.name)]
         for p in prop.target.properties.values():
+            pdtype = assert_isinstance(p, DataProperty).datatype.get_sqlalchemy_type()
+            for dep in pdtype.deps:
+                program.import_(dep, True)
+
             propvalargs.append(
                 expr.ExprFuncCall(
                     expr.ExprIdent("mapped_column"),
                     [
                         expr.ExprConstant(f"{prop.name}_{p.name}"),
-                        expr.ExprIdent(
-                            assert_isinstance(p, DataProperty)
-                            .datatype.get_sqlalchemy_type()
-                            .type
-                        ),
+                        expr.ExprIdent(pdtype.type),
                         PredefinedFn.keyword_assignment(
                             "nullable",
                             expr.ExprConstant(prop.is_optional or p.is_optional),
@@ -1391,7 +1551,11 @@ def make_python_relational_object_property(
 
 
 def make_python_relational_object_property_many_to_many(
-    program: Program, ast: AST, target_pkg: Package, cls: Class, prop: ObjectProperty
+    program: Program,
+    ast: AST,
+    target_pkg: Package,
+    cls: Class,
+    prop: ObjectProperty,
 ):
     assert cls.db is not None
     assert prop.db is not None and prop.target.db is not None
@@ -1415,16 +1579,19 @@ def make_python_relational_object_property_many_to_many(
     newprogram.import_("sqlalchemy.orm.Mapped", True)
     newprogram.import_("sqlalchemy.orm.relationship", True)
     newprogram.import_(f"{target_pkg.path}.base.Base", True)
-    newprogram.import_("typing.TYPE_CHECKING", True)
-    newprogram.import_area.if_(expr.ExprIdent("TYPE_CHECKING"))(
-        lambda ast00: ast00.import_(
-            target_pkg.path + f".{cls.get_pymodule_name()}.{cls.name}",
-            is_import_attr=True,
-        ),
-        lambda ast10: ast10.import_(
-            target_pkg.path + f".{prop.target.get_pymodule_name()}.{prop.target.name}",
-            is_import_attr=True,
-        ),
+
+    ident_manager = ImportHelper(
+        newprogram,
+        GLOBAL_IDENTS,
+    )
+
+    ident_manager.python_import_for_hint(
+        target_pkg.path + f".{cls.get_pymodule_name()}.{cls.name}",
+        is_import_attr=True,
+    )
+    ident_manager.python_import_for_hint(
+        target_pkg.path + f".{prop.target.get_pymodule_name()}.{prop.target.name}",
+        is_import_attr=True,
     )
 
     newprogram.root(

sera/make/make_python_services.py

@@ -32,11 +32,12 @@ def make_python_service(collection: DataCollection, target_pkg: Package):
     program = Program()
     program.import_("__future__.annotations", True)
     program.import_(
-        app.models.db.path + f".{collection.get_pymodule_name()}.{collection.name}",
+        app.models.db.path + f".{collection.name}",
         True,
     )
     program.import_(app.config.path + f".schema", True)
     program.import_("sera.libs.base_service.BaseAsyncService", True)
+    program.import_(app.models.db.path + ".dbschema", True)
 
     program.root(
         stmt.LineBreak(),
@@ -55,7 +56,7 @@ def make_python_service(collection: DataCollection, target_pkg: Package):
                         expr.ExprIdent("super().__init__"),
                         [
                             expr.ExprRawPython(f"schema.classes['{cls.name}']"),
-                            expr.ExprIdent(cls.name),
+                            expr.ExprIdent("dbschema"),
                         ],
                     )
                 ),

sera/make/make_typescript_model.py

@@ -1242,6 +1242,18 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         if tstype.type in schema.enums
                         else []
                     ),
+                    *(
+                        [
+                            (
+                                expr.ExprIdent("foreignKeyTarget"),
+                                expr.ExprConstant(prop.db.foreign_key.name),
+                            )
+                        ]
+                        if prop.db is not None
+                        and prop.db.is_primary_key
+                        and prop.db.foreign_key is not None
+                        else []
+                    ),
                     (
                         expr.ExprIdent("isRequired"),
                         expr.ExprConstant(
@@ -1618,14 +1630,19 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
     if m is not None:
         # This is an array type, add string to the inner type
         inner_type = m.group(1)
+        inner_spectype = assert_not_null(
+            re.match(r"(\(?[a-zA-Z \|]+\)?)(\[\])", tstype.spectype)
+        ).group(1)
         if "string" not in inner_type:
             if inner_type.startswith("(") and inner_type.endswith(")"):
                 # Already has parentheses
                 inner_type = f"{inner_type[:-1]} | string)"
+                inner_spectype = f"{inner_spectype[:-1]} | string)"
             else:
                 # Need to add parentheses
                 inner_type = f"({inner_type} | string)"
-        return TsTypeWithDep(inner_type + "[]", tstype.deps)
+                inner_spectype = f"({inner_spectype} | string)"
+        return TsTypeWithDep(inner_type + "[]", inner_spectype + "[]", tstype.deps)
 
     m = re.match(r"^\(?[a-zA-Z \|]+\)?$", tstype.type)
     if m is not None:
@@ -1633,10 +1650,12 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
             if tstype.type.startswith("(") and tstype.type.endswith(")"):
                 # Already has parentheses
                 new_type = f"{tstype.type[:-1]} | string)"
+                new_spectype = f"{tstype.spectype[:-1]} | string)"
             else:
                 # Needs parentheses for clarity
                 new_type = f"({tstype.type} | string)"
-            return TsTypeWithDep(new_type, tstype.deps)
+                new_spectype = f"({tstype.spectype} | string)"
+            return TsTypeWithDep(new_type, new_spectype, tstype.deps)
         return tstype
 
     raise NotImplementedError(tstype.type)

sera/misc/__init__.py

@@ -12,6 +12,7 @@ from sera.misc._utils import (
     load_data_from_dir,
     replay_events,
     to_camel_case,
+    to_kebab_case,
     to_pascal_case,
     to_snake_case,
 )
@@ -34,4 +35,5 @@ __all__ = [
     "load_data_from_dir",
     "replay_events",
     "auto_import",
+    "to_kebab_case",
 ]

sera/misc/_utils.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import inspect
 import re
 from collections import defaultdict
+from curses.ascii import isupper
+from functools import lru_cache
 from importlib import import_module
 from pathlib import Path
 from typing import (
@@ -82,13 +84,16 @@ def import_attr(attr_ident: str):
     return getattr(module, cls)
 
 
-def to_snake_case(camelcase: str) -> str:
+@lru_cache(maxsize=1280)
+def to_snake_case(name: str) -> str:
     """Convert camelCase to snake_case."""
-    snake = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", camelcase)
+    snake = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
     snake = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", snake)
+    snake = snake.replace("-", "_")
     return snake.lower()
 
 
+@lru_cache(maxsize=1280)
 def to_camel_case(snake: str) -> str:
     """Convert snake_case to camelCase."""
     components = snake.split("_")
@@ -99,6 +104,7 @@ def to_camel_case(snake: str) -> str:
     return out
 
 
+@lru_cache(maxsize=1280)
 def to_pascal_case(snake: str) -> str:
     """Convert snake_case to PascalCase."""
     components = snake.split("_")
@@ -109,6 +115,15 @@ def to_pascal_case(snake: str) -> str:
     return out
 
 
+@lru_cache(maxsize=1280)
+def to_kebab_case(name: str) -> str:
+    """Convert a name to kebab-case."""
+    kebab = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1-\2", name)
+    kebab = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", kebab)
+    kebab = kebab.replace("_", "-")
+    return kebab.lower()
+
+
 def assert_isinstance(x: Any, cls: type[T]) -> T:
     if not isinstance(x, cls):
         raise Exception(f"{type(x)} doesn't match with {type(cls)}")

sera/models/_class.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Optional
 
-from sera.misc import to_snake_case
+from sera.misc import to_kebab_case, to_snake_case
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._property import DataProperty, ObjectProperty
 
@@ -80,4 +80,4 @@ class Class:
 
     def get_tsmodule_name(self) -> str:
         """Get the typescript module name of this class as if there is a typescript module created to store this class only."""
-        return self.name[0].lower() + self.name[1:]
+        return to_kebab_case(self.name)

sera/models/_collection.py

@@ -23,7 +23,7 @@ class DataCollection:
         """Get the python module name of this collection as if there is a python module created to store this collection only."""
         return self.cls.get_pymodule_name()
 
-    def get_queryable_fields(self) -> list[tuple[str, tuple[str, str]]]:
+    def get_queryable_fields(self) -> list[str]:
         """Get the fields of this collection that can be used in a queries."""
         output = []
         for prop in self.cls.properties.values():
@@ -48,17 +48,21 @@ class DataCollection:
                 # This property is a data property or an object property not stored in the database, so we use its name
                 propname = prop.name
 
-            if isinstance(prop, DataProperty):
-                convert_func = prop.datatype.pytype.get_string_conversion_func()
-            else:
-                assert isinstance(prop, ObjectProperty) and prop.target.db is not None
-                target_idprop = prop.target.get_id_property()
-                assert target_idprop is not None
-                convert_func = (
-                    target_idprop.datatype.pytype.get_string_conversion_func()
-                )
+            output.append(propname)
+        return output
+
+    def get_join_queryable_fields(self) -> dict[str, list[str]]:
+        """Get the fields of this collection that can be used in join queries."""
+        output = {}
+        for prop in self.cls.properties.values():
+            if isinstance(prop, DataProperty) and prop.db.foreign_key is not None:
+                # This property is a foreign key, so we add it to the output
+                output[prop.name] = DataCollection(
+                    prop.db.foreign_key
+                ).get_queryable_fields()
+            elif isinstance(prop, ObjectProperty) and prop.target.db is not None:
+                output[prop.name] = DataCollection(prop.target).get_queryable_fields()
 
-            output.append((propname, convert_func))
         return output
 
     def get_service_name(self):

sera/models/_constraints.py

@@ -25,7 +25,7 @@ class Constraint:
             # the UI will ensure to submit it in E.164 format
             return r"msgspec.Meta(pattern=r'^\+[1-9]\d{1,14}$')"
         elif self.name == "email":
-            return r"msgspec.Meta(min_length=3, max_length=254, pattern=r'^[^@]+@[^@]+\.[^@]+$')"
+            return r"msgspec.Meta(min_length=3, max_length=254, pattern=r'^[^@]+@[^@]+\.[a-zA-Z\.]+$')"
         elif self.name == "not_empty":
             return "msgspec.Meta(min_length=1)"
         elif self.name == "username":

sera/models/_datatype.py

@@ -2,12 +2,10 @@ from __future__ import annotations
 
 import datetime
 from dataclasses import dataclass, field
-from typing import Callable, Literal
+from typing import Literal
 
 from codegen.models import expr
 
-from sera.misc import identity
-
 PyDataType = Literal["str", "int", "datetime", "float", "bool", "bytes", "dict"]
 TypescriptDataType = Literal["string", "number", "boolean"]
 SQLAlchemyDataType = Literal[
@@ -69,30 +67,8 @@ class PyTypeWithDep:
         """Clone the type with the same dependencies."""
         return PyTypeWithDep(type=self.type, deps=list(self.deps))
 
-    def get_string_conversion_func(self) -> tuple[str, str]:
-        if self.type == "str":
-            return ("identity", "sera.misc.identity")
-        if self.type == "int":
-            return ("TypeConversion.to_int", "sera.libs.api_helper.TypeConversion")
-        if self.type == "float":
-            return ("TypeConversion.to_float", "sera.libs.api_helper.TypeConversion")
-        if self.type == "bool":
-            return ("TypeConversion.to_bool", "sera.libs.api_helper.TypeConversion")
-        if any(
-            dep.find(".models.enums.") != -1 and dep.endswith(self.type)
-            for dep in self.deps
-        ):
-            # This is an enum type, we directly use the enum constructor as the conversion function
-            return (
-                self.type,
-                [
-                    dep
-                    for dep in self.deps
-                    if dep.find(".models.enums.") != -1 and dep.endswith(self.type)
-                ][0],
-            )
-        else:
-            raise NotImplementedError()
+    def is_enum_type(self) -> bool:
+        return any(x.find(".models.enums.") != -1 for x in self.deps)
 
 
 @dataclass
@@ -153,7 +129,7 @@ class TsTypeWithDep:
             return value
         if self.type == "Date":
             return expr.ExprRawTypescript(f"new Date({value.to_typescript()})")
-        if any(x.startswith("@.models.enum") for x in self.deps):
+        if self.is_enum_type():
             # enum type, we don't need to do anything as we use strings for enums
             return value
         raise ValueError(f"Unknown type: {self.type}")
@@ -174,11 +150,14 @@ class TsTypeWithDep:
             return expr.ExprRawTypescript(f"{value.to_typescript()}.toISOString()")
         if self.type == "Date | undefined":
             return expr.ExprRawTypescript(f"{value.to_typescript()}?.toISOString()")
-        if any(x.startswith("@.models.enum") for x in self.deps):
+        if self.is_enum_type():
             # enum type, we don't need to do anything as we use strings for enums
             return value
         raise ValueError(f"Unknown type: {self.type}")
 
+    def is_enum_type(self) -> bool:
+        return any(x.startswith("@.models.enums.") for x in self.deps)
+
 
 @dataclass
 class SQLTypeWithDep:

sera/models/_enum.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections import Counter
 from dataclasses import dataclass
 
-from sera.misc import to_snake_case
+from sera.misc import to_kebab_case, to_snake_case
 from sera.models._multi_lingual_string import MultiLingualString
 
 
@@ -44,7 +44,7 @@ class Enum:
 
     def get_tsmodule_name(self) -> str:
         """Get the typescript module name of this enum as if there is a typescript module created to store this enum only."""
-        return self.name[0].lower() + self.name[1:]
+        return to_kebab_case(self.name)
 
     def is_str_enum(self) -> bool:
         """Check if this enum is a string enum."""

sera/models/_module.py

@@ -39,6 +39,13 @@ class Package:
         """Create a module in this package"""
         return Module(self, name, self.language)
 
+    def parent(self) -> Package:
+        """Get the parent package"""
+        assert self.path.count(".") > 0, "Cannot get parent of top-level package"
+        return Package(
+            self.app, self.path.rsplit(".", 1)[0], self.dir.parent, self.language
+        )
+
 
 @dataclass
 class Module:

{sera_2-1.21.2.dist-info → sera_2-1.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.21.2
+Version: 1.23.0
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: black (==25.1.0)
-Requires-Dist: codegen-2 (>=2.12.2,<3.0.0)
+Requires-Dist: codegen-2 (>=2.14.0,<3.0.0)
 Requires-Dist: graph-wrapper (>=1.7.3,<2.0.0)
 Requires-Dist: isort (==6.0.1)
 Requires-Dist: litestar (>=2.15.1,<3.0.0)