sera-2 1.13.0__tar.gz → 1.14.0__tar.gz

{sera_2-1.13.0 → sera_2-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sera-2
-Version: 1.13.0
+Version: 1.14.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,<26.0.0)
-Requires-Dist: codegen-2 (>=2.11.0,<3.0.0)
+Requires-Dist: codegen-2 (>=2.11.1,<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)

{sera_2-1.13.0 → sera_2-1.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sera-2"
-version = "1.13.0"
+version = "1.14.0"
 description = ""
 authors = ["Binh Vu <bvu687@gmail.com>"]
 readme = "README.md"
@@ -9,7 +9,7 @@ repository = "https://github.com/binh-vu/sera"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-codegen-2 = "^2.11.0"
+codegen-2 = "^2.11.1"
 msgspec = "^0.19.0"
 litestar = "^2.15.1"
 loguru = "^0.7.0"

sera_2-1.14.0/sera/exports/schema.py

@@ -0,0 +1,183 @@
+from pathlib import Path
+from typing import Annotated
+
+import orjson
+import typer
+
+from sera.misc import assert_not_null, to_snake_case
+from sera.models import Cardinality, DataProperty, Schema, parse_schema
+
+
+def export_tbls(schema: Schema, outfile: Path):
+    out = {
+        "name": schema.name,
+        "tables": [],
+        "relations": [],
+    }
+
+    DUMMY_IDPROP = "dkey"
+
+    for cls in schema.topological_sort():
+        table = {
+            "name": cls.name,
+            "type": "BASE TABLE",
+            "columns": [],
+            "constraints": [],
+        }
+
+        if cls.db is None:
+            # This class has no database mapping, we must generate a default key for it
+            table["columns"].append(
+                {
+                    "name": DUMMY_IDPROP,
+                    "type": "UNSET",
+                    "nullable": False,
+                }
+            )
+
+        for prop in cls.properties.values():
+            column = {
+                "name": prop.name,
+                "nullable": not prop.is_optional,
+            }
+
+            if isinstance(prop, DataProperty):
+                column["type"] = prop.datatype.get_python_type().type
+                if prop.db is not None and prop.db.is_primary_key:
+                    table["constraints"].append(
+                        {
+                            "name": f"{cls.name}_pkey",
+                            "type": "PRIMARY KEY",
+                            "def": f"PRIMARY KEY ({prop.name})",
+                            "table": cls.name,
+                            "referenced_table": cls.name,
+                            "columns": [prop.name],
+                        }
+                    )
+            else:
+                if prop.cardinality == Cardinality.MANY_TO_MANY:
+                    # For many-to-many relationships, we need to create a join table
+                    jointable = {
+                        "name": f"{cls.name}{prop.target.name}",
+                        "type": "JOIN TABLE",
+                        "columns": [
+                            {
+                                "name": f"{to_snake_case(cls.name)}_id",
+                                "type": assert_not_null(cls.get_id_property())
+                                .datatype.get_python_type()
+                                .type,
+                                "nullable": False,
+                            },
+                            {
+                                "name": f"{to_snake_case(prop.target.name)}_id",
+                                "type": assert_not_null(prop.target.get_id_property())
+                                .datatype.get_python_type()
+                                .type,
+                                "nullable": False,
+                            },
+                        ],
+                    }
+                    out["tables"].append(jointable)
+                    out["relations"].extend(
+                        [
+                            {
+                                "table": f"{cls.name}{prop.target.name}",
+                                "columns": [f"{to_snake_case(cls.name)}_id"],
+                                "cardinality": "zero_or_more",
+                                "parent_table": cls.name,
+                                "parent_columns": [
+                                    assert_not_null(cls.get_id_property()).name
+                                ],
+                                "parent_cardinality": "zero_or_one",
+                                "def": "",  # LiamERD does not use `def` so we can leave it empty for now
+                            },
+                            {
+                                "table": f"{cls.name}{prop.target.name}",
+                                "columns": [f"{to_snake_case(prop.target.name)}_id"],
+                                "cardinality": "zero_or_more",
+                                "parent_table": prop.target.name,
+                                "parent_columns": [
+                                    assert_not_null(prop.target.get_id_property()).name
+                                ],
+                                "parent_cardinality": "zero_or_one",
+                                "def": "",
+                            },
+                        ]
+                    )
+                    # we actually want to skip adding this N-to-N column
+                    continue
+
+                if prop.target.db is not None:
+                    idprop = assert_not_null(prop.target.get_id_property())
+                    idprop_name = idprop.name
+                    column["type"] = idprop.datatype.get_python_type().type
+                else:
+                    column["type"] = prop.target.name
+                    idprop_name = (
+                        DUMMY_IDPROP  # a dummy property name for visualization purposes
+                    )
+                    assert idprop_name not in prop.target.properties
+
+                # somehow LiamERD only support zero_or_more or zero_or_one (exactly one does not work)
+                if prop.cardinality == Cardinality.ONE_TO_ONE:
+                    cardinality = "zero_or_one"
+                    parent_cardinality = "zero_or_one"
+                elif prop.cardinality == Cardinality.ONE_TO_MANY:
+                    cardinality = "zero_or_one"
+                    parent_cardinality = "zero_or_more"
+                elif prop.cardinality == Cardinality.MANY_TO_ONE:
+                    cardinality = "zero_or_more"
+                    parent_cardinality = "zero_or_one"
+                elif prop.cardinality == Cardinality.MANY_TO_MANY:
+                    raise Exception("Unreachable")
+
+                out["relations"].append(
+                    {
+                        "table": cls.name,
+                        "columns": [prop.name],
+                        "cardinality": cardinality,
+                        "parent_table": prop.target.name,
+                        "parent_columns": [idprop_name],
+                        "parent_cardinality": parent_cardinality,
+                        "def": f"FOREIGN KEY ({prop.name}) REFERENCES {prop.target.name}({idprop_name})",
+                    }
+                )
+
+            table["columns"].append(column)
+
+        out["tables"].append(table)
+
+    outfile.parent.mkdir(parents=True, exist_ok=True)
+    outfile.write_bytes(orjson.dumps(out, option=orjson.OPT_INDENT_2))
+
+
+app = typer.Typer(pretty_exceptions_short=True, pretty_exceptions_enable=False)
+
+
+@app.command()
+def cli(
+    schema_files: Annotated[
+        list[Path],
+        typer.Option(
+            "-s", help="YAML schema files. Multiple files are merged automatically"
+        ),
+    ],
+    outfile: Annotated[
+        Path,
+        typer.Option(
+            "-o", "--output", help="Output file for the tbls schema", writable=True
+        ),
+    ],
+):
+    schema = parse_schema(
+        "sera",
+        schema_files,
+    )
+    export_tbls(
+        schema,
+        outfile,
+    )
+
+
+if __name__ == "__main__":
+    app()

sera_2-1.14.0/sera/libs/api_test_helper.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from litestar import Litestar
+from litestar.testing import TestClient
+
+
+def test_has(
+    client: TestClient[Litestar],
+    base_url: str,
+    exist_records: list[int | str],
+    non_exist_records: list[int | str],
+) -> None:
+    for record in exist_records:
+        resp = client.head(f"{base_url}/{record}")
+        assert (
+            resp.status_code == 204
+        ), f"Record {record} should exist but got {resp.status_code}"
+
+    for record in non_exist_records:
+        resp = client.head(f"{base_url}/{record}")
+        assert (
+            resp.status_code == 404
+        ), f"Record {record} should not exist but got {resp.status_code}"
+
+
+def test_get_by_id(
+    client: TestClient[Litestar],
+    base_url: str,
+    exist_records: dict[int | str, dict],
+    non_exist_records: list[int | str],
+) -> None:
+    for record, data in exist_records.items():
+        resp = client.get(f"{base_url}/{record}")
+        assert (
+            resp.status_code == 200
+        ), f"Record {record} should exist but got {resp.status_code}"
+        assert resp.json() == data
+
+    for record in non_exist_records:
+        resp = client.get(f"{base_url}/{record}")
+        assert (
+            resp.status_code == 404
+        ), f"Record {record} should not exist but got {resp.status_code}"

{sera_2-1.13.0 → sera_2-1.14.0}/sera/make/make_python_api.py

@@ -7,8 +7,7 @@ from loguru import logger
 
 from sera.misc import assert_not_null, to_snake_case
 from sera.models import App, DataCollection, Module, Package, SystemControlledMode
-
-GLOBAL_IDENTS = {"AsyncSession": "sqlalchemy.ext.asyncio.AsyncSession"}
+from sera.typing import GLOBAL_IDENTS
 
 
 def make_python_api(app: App, collections: Sequence[DataCollection]):
@@ -544,19 +543,20 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
     )
     program.import_(
         app.models.data.path
-        + f".{collection.get_pymodule_name()}.Upsert{collection.name}",
+        + f".{collection.get_pymodule_name()}.Create{collection.name}",
         True,
     )
 
     # assuming the collection has only one class
     cls = collection.cls
-    has_restricted_system_controlled_prop = any(
-        prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+    is_on_create_update_props = any(
+        prop.data.system_controlled is not None
+        and prop.data.system_controlled.is_on_create_value_updated()
         for prop in cls.properties.values()
     )
     idprop = assert_not_null(cls.get_id_property())
 
-    if has_restricted_system_controlled_prop:
+    if is_on_create_update_props:
         program.import_("sera.libs.api_helper.SingleAutoUSCP", True)
 
     func_name = "create"
@@ -575,11 +575,11 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
                             "dto",
                             PredefinedFn.item_getter(
                                 expr.ExprIdent("SingleAutoUSCP"),
-                                expr.ExprIdent(f"Upsert{cls.name}"),
+                                expr.ExprIdent(f"Create{cls.name}"),
                             ),
                         )
                     ]
-                    if has_restricted_system_controlled_prop
+                    if is_on_create_update_props
                     else []
                 ),
             )
@@ -589,7 +589,7 @@ def make_python_create_api(collection: DataCollection, target_pkg: Package):
             [
                 DeferredVar.simple(
                     "data",
-                    expr.ExprIdent(f"Upsert{cls.name}"),
+                    expr.ExprIdent(f"Create{cls.name}"),
                 ),
                 DeferredVar.simple(
                     "session",
@@ -652,7 +652,7 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
     )
     program.import_(
         app.models.data.path
-        + f".{collection.get_pymodule_name()}.Upsert{collection.name}",
+        + f".{collection.get_pymodule_name()}.Update{collection.name}",
         True,
     )
 
@@ -661,11 +661,12 @@ 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_restricted_system_controlled_prop = any(
-        prop.data.is_system_controlled == SystemControlledMode.RESTRICTED
+    is_on_update_update_props = any(
+        prop.data.system_controlled is not None
+        and prop.data.system_controlled.is_on_update_value_updated()
         for prop in cls.properties.values()
     )
-    if has_restricted_system_controlled_prop:
+    if is_on_update_update_props:
         program.import_("sera.libs.api_helper.SingleAutoUSCP", True)
 
     func_name = "update"
@@ -684,11 +685,11 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
                             "dto",
                             PredefinedFn.item_getter(
                                 expr.ExprIdent("SingleAutoUSCP"),
-                                expr.ExprIdent(f"Upsert{cls.name}"),
+                                expr.ExprIdent(f"Update{cls.name}"),
                             ),
                         )
                     ]
-                    if has_restricted_system_controlled_prop
+                    if is_on_update_update_props
                     else []
                 ),
             )
@@ -702,7 +703,7 @@ def make_python_update_api(collection: DataCollection, target_pkg: Package):
                 ),
                 DeferredVar.simple(
                     "data",
-                    expr.ExprIdent(f"Upsert{cls.name}"),
+                    expr.ExprIdent(f"Update{cls.name}"),
                 ),
                 DeferredVar.simple(
                     "session",