sera-2 1.15.0__tar.gz → 1.17.0__tar.gz

{sera_2-1.15.0 → sera_2-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.15.0
+Version: 1.17.0
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com

{sera_2-1.15.0 → sera_2-1.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sera-2"
-version = "1.15.0"
+version = "1.17.0"
 description = ""
 authors = ["Binh Vu <bvu687@gmail.com>"]
 readme = "README.md"

{sera_2-1.15.0 → sera_2-1.17.0}/sera/exports/schema.py

@@ -54,6 +54,20 @@ def export_tbls(schema: Schema, outfile: Path):
                             "columns": [prop.name],
                         }
                     )
+
+                    if prop.db.foreign_key is not None:
+                        idprop = assert_not_null(prop.db.foreign_key.get_id_property())
+                        out["relations"].append(
+                            {
+                                "table": cls.name,
+                                "columns": [prop.name],
+                                "cardinality": "zero_or_one",
+                                "parent_table": prop.db.foreign_key.name,
+                                "parent_columns": [idprop_name],
+                                "parent_cardinality": "zero_or_one",
+                                "def": f"FOREIGN KEY ({prop.name}) REFERENCES {prop.db.foreign_key.name}({idprop_name})",
+                            }
+                        )
             else:
                 if prop.cardinality == Cardinality.MANY_TO_MANY:
                     # For many-to-many relationships, we need to create a join table

{sera_2-1.15.0 → sera_2-1.17.0}/sera/make/make_python_model.py

@@ -1079,12 +1079,10 @@ def make_python_relational_model(
 
         target_pkg.module("base").write(program)
 
-    custom_types: list[ObjectProperty] = []
-
-    for cls in schema.topological_sort():
+    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
-            continue
+            return
 
         program = Program()
         program.import_("__future__.annotations", True)
@@ -1093,6 +1091,11 @@ def make_python_relational_model(
         program.import_("sqlalchemy.orm.Mapped", True)
         program.import_(f"{target_pkg.path}.base.Base", True)
 
+        ident_manager = ImportHelper(
+            program,
+            GLOBAL_IDENTS,
+        )
+
         index_stmts = []
         if len(cls.db.indices) > 0:
             program.import_("sqlalchemy.Index", True)
@@ -1159,6 +1162,32 @@ def make_python_relational_model(
                     proptype = f"Mapped[{sqltype.mapped_pytype}]"
 
                 propvalargs: list[expr.Expr] = [expr.ExprIdent(sqltype.type)]
+                if prop.db.foreign_key is not None:
+                    assert (
+                        prop.db.foreign_key.db is not None
+                    ), f"Foreign key {prop.db.foreign_key.name} must have a database mapping"
+                    foreign_key_idprop = prop.db.foreign_key.get_id_property()
+                    assert (
+                        foreign_key_idprop is not None
+                    ), f"Foreign key {prop.db.foreign_key.name} must have an id property"
+                    propvalargs.append(
+                        expr.ExprFuncCall(
+                            ident_manager.use("ForeignKey"),
+                            [
+                                expr.ExprConstant(
+                                    f"{prop.db.foreign_key.db.table_name}.{foreign_key_idprop.name}"
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "ondelete",
+                                    expr.ExprConstant("CASCADE"),
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "onupdate",
+                                    expr.ExprConstant("CASCADE"),
+                                ),
+                            ],
+                        )
+                    )
                 if prop.db.is_primary_key:
                     propvalargs.append(
                         PredefinedFn.keyword_assignment(
@@ -1208,6 +1237,11 @@ def make_python_relational_model(
 
         target_pkg.module(cls.get_pymodule_name()).write(program)
 
+    custom_types: list[ObjectProperty] = []
+
+    for cls in schema.topological_sort():
+        make_orm(cls)
+
     # make a base class that implements the mapping for custom types
     custom_types = filter_duplication(
         custom_types, lambda p: (p.target.name, p.cardinality, p.is_optional, p.is_map)

{sera_2-1.15.0 → sera_2-1.17.0}/sera/make/make_typescript_model.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
-from codegen.models import AST, PredefinedFn, Program, expr, stmt
+from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
 from codegen.models.var import DeferredVar
 from loguru import logger
 
 from sera.misc import (
     assert_isinstance,
     assert_not_null,
+    identity,
     to_camel_case,
     to_pascal_case,
     to_snake_case,
@@ -25,6 +26,11 @@ from sera.models import (
 )
 from sera.typing import is_set
 
+TS_GLOBAL_IDENTS = {
+    "normalizers.normalizeNumber": "sera-db.normalizers",
+    "normalizers.normalizeOptionalNumber": "sera-db.normalizers",
+}
+
 
 def make_typescript_data_model(schema: Schema, target_pkg: Package):
     """Generate TypeScript data model from the schema. The data model aligns with the public data model in Python, not the database model."""
@@ -259,6 +265,8 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         program.import_("mobx.action", True)
         program.import_("sera-db.validators", True)
 
+        import_helper = ImportHelper(program, TS_GLOBAL_IDENTS)
+
         program.root(
             stmt.LineBreak(),
             stmt.TypescriptStatement(
@@ -331,12 +339,15 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
 
             if isinstance(prop, DataProperty):
                 tstype = prop.get_data_model_datatype().get_typescript_type()
+                original_tstype = tstype
+
                 if idprop is not None and prop.name == idprop.name:
                     # use id type alias
                     tstype = TsTypeWithDep(
                         f"{cls.name}Id",
                         deps=[f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id"],
                     )
+                    original_tstype = tstype
                 elif tstype.type not in schema.enums:
                     # for none id & none enum properties, we need to include a type for "invalid" value
                     tstype = _inject_type_for_invalid_value(tstype)
@@ -344,6 +355,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                 if prop.is_optional:
                     # convert type to optional
                     tstype = tstype.as_optional_type()
+                    original_tstype = original_tstype.as_optional_type()
 
                 for dep in tstype.deps:
                     program.import_(dep, True)
@@ -400,6 +412,11 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         expr.ExprIdent("record"), expr.ExprIdent(propname)
                     )
 
+                if original_tstype.type != tstype.type:
+                    norm_func = get_norm_func(original_tstype, import_helper)
+                else:
+                    norm_func = identity
+
                 ser_args.append(
                     (
                         expr.ExprIdent(prop.name),
@@ -420,14 +437,18 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                                     ),
                                     expr.ExprIdent("isValid"),
                                 ),
-                                PredefinedFn.attr_getter(
-                                    expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                norm_func(
+                                    PredefinedFn.attr_getter(
+                                        expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                    )
                                 ),
                                 expr.ExprIdent("undefined"),
                             )
                             if prop.is_optional
-                            else PredefinedFn.attr_getter(
-                                expr.ExprIdent("this"), expr.ExprIdent(propname)
+                            else norm_func(
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                )
                             )
                         ),
                     )
@@ -455,14 +476,19 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                                         ),
                                         expr.ExprIdent("isValid"),
                                     ),
-                                    PredefinedFn.attr_getter(
-                                        expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                    norm_func(
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprIdent("this"),
+                                            expr.ExprIdent(propname),
+                                        )
                                     ),
                                     expr.ExprIdent("undefined"),
                                 )
                                 if prop.is_optional
-                                else PredefinedFn.attr_getter(
-                                    expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                else norm_func(
+                                    PredefinedFn.attr_getter(
+                                        expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                    )
                                 )
                             ),
                         )
@@ -1086,6 +1112,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
 
         program = Program()
         prop_defs: list[tuple[DataProperty | ObjectProperty, expr.Expr, expr.Expr]] = []
+        prop_normalizers: list[tuple[expr.Expr, expr.Expr]] = []
+
+        import_helper = ImportHelper(program, TS_GLOBAL_IDENTS)
 
         for prop in cls.properties.values():
             # we must include private properties that are needed during upsert for our forms.
@@ -1126,6 +1155,11 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         ),
                     ),
                 ]
+
+                norm_func = get_normalizer(tstype, import_helper)
+                if norm_func is not None:
+                    # we have a normalizer for this type
+                    prop_normalizers.append((expr.ExprIdent(propname), norm_func))
             else:
                 assert isinstance(prop, ObjectProperty)
                 if prop.target.db is not None:
@@ -1340,6 +1374,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             expr.ExprIdent("validators"),
                             expr.ExprIdent(f"draft{cls.name}Validators"),
                         ),
+                        (
+                            expr.ExprIdent("normalizers"),
+                            PredefinedFn.dict(prop_normalizers),
+                        ),
                     ]
                     + (
                         [
@@ -1500,3 +1538,35 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
         return tstype
 
     raise NotImplementedError(tstype.type)
+
+
+def get_normalizer(
+    tstype: TsTypeWithDep, import_helper: ImportHelper
+) -> Optional[expr.ExprIdent]:
+    if tstype.type == "number":
+        return import_helper.use("normalizers.normalizeNumber")
+    if tstype.type == "number | undefined":
+        return import_helper.use("normalizers.normalizeOptionalNumber")
+
+    assert "number" not in tstype.type, tstype.type
+    return None
+
+
+def get_norm_func(
+    tstype: TsTypeWithDep, import_helper: ImportHelper
+) -> Callable[[expr.Expr], expr.Expr]:
+    """
+    Get the normalizer function for the given TypeScript type.
+    If no normalizer is available, return None.
+    """
+    norm_func = get_normalizer(tstype, import_helper)
+    if norm_func is not None:
+
+        def modify_expr(value: expr.Expr) -> expr.Expr:
+            return expr.ExprFuncCall(
+                norm_func,
+                [value],
+            )
+
+        return modify_expr
+    return identity  # Return the value as is if no normalizer is available

{sera_2-1.15.0 → sera_2-1.17.0}/sera/misc/__init__.py

@@ -3,6 +3,7 @@ from sera.misc._utils import (
     assert_isinstance,
     assert_not_null,
     filter_duplication,
+    identity,
     load_data,
     to_camel_case,
     to_pascal_case,
@@ -20,4 +21,5 @@ __all__ = [
     "Formatter",
     "File",
     "load_data",
+    "identity",
 ]

{sera_2-1.15.0 → sera_2-1.17.0}/sera/misc/_utils.py

@@ -148,3 +148,8 @@ def load_data(
                 )
             )
         session.commit()
+
+
+def identity(x: T) -> T:
+    """Identity function that returns the input unchanged."""
+    return x

{sera_2-1.15.0 → sera_2-1.17.0}/sera/models/_parse.py

@@ -160,6 +160,7 @@ def _parse_property(
                     is_indexed=db.get("is_indexed", False)
                     or db.get("is_unique", False)
                     or db.get("is_primary_key", False),
+                    foreign_key=schema.classes.get(db.get("foreign_key")),
                 )
                 if "db" in prop
                 else None

{sera_2-1.15.0 → sera_2-1.17.0}/sera/models/_property.py

@@ -150,6 +150,12 @@ class DataPropDBInfo:
     is_unique: bool = False
     # whether this property is indexed or not
     is_indexed: bool = False
+    # this is used in conjunction with is_primary_key = True for the case of
+    # extending a table with frequently updated properties. The value for the `foreign_key`
+    # will be a target class. The cardinality is one-to-one, on target class deletion,
+    # this class will be deleted as well (because it's an extended table of the target class).
+    # on source (this class) deletion, the target class will not be deleted.
+    foreign_key: Optional[Class] = None
 
 
 @dataclass(kw_only=True)

{sera_2-1.15.0 → sera_2-1.17.0}/sera/typing.py

@@ -37,4 +37,5 @@ GLOBAL_IDENTS = {
     "AsyncSession": "sqlalchemy.ext.asyncio.AsyncSession",
     "ASGIConnection": "litestar.connection.ASGIConnection",
     "UNSET": "sera.typing.UNSET",
+    "ForeignKey": "sqlalchemy.ForeignKey",
 }