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

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

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

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

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

{sera_2-1.16.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.16.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.16.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.16.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.16.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",
 }