PyPI - sera-2 - Versions diffs - 1.11.2__tar.gz → 1.12.0__tar.gz - Mend

sera-2 1.11.2tar.gz → 1.12.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

{sera_2-1.11.2 → sera_2-1.12.0}/PKG-INFO RENAMED Viewed

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

{sera_2-1.11.2 → sera_2-1.12.0}/pyproject.toml RENAMED Viewed

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

{sera_2-1.11.2 → sera_2-1.12.0}/sera/make/make_python_model.py RENAMED Viewed

@@ -1,5 +1,6 @@
 from __future__ import annotations
+from operator import is_
 from typing import Callable, Sequence
 from codegen.models import AST, DeferredVar, PredefinedFn, Program, expr, stmt
@@ -296,11 +297,14 @@ def make_python_data_model(
                         ],
                     )
+                if prop.cardinality.is_star_to_many():
+                    pytype = pytype.as_list_type()
+                elif prop.is_optional:
+                    pytype = pytype.as_optional_type()
                 for dep in pytype.deps:
                     program.import_(dep, True)
-                if prop.cardinality.is_star_to_many():
-                    pytype = pytype.as_list_type()
                 cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
         # has_to_db = True
@@ -453,11 +457,14 @@ def make_python_data_model(
                         ],
                     )
+                if prop.cardinality.is_star_to_many():
+                    pytype = pytype.as_list_type()
+                elif prop.is_optional:
+                    pytype = pytype.as_optional_type()
                 for dep in pytype.deps:
                     program.import_(dep, True)
-                if prop.cardinality.is_star_to_many():
-                    pytype = pytype.as_list_type()
                 cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
         cls_ast(
@@ -690,7 +697,12 @@ def make_python_relational_model(
                     program.import_(dep, True)
                 propname = prop.name
-                proptype = f"Mapped[{sqltype.mapped_pytype}]"
+                if prop.is_optional:
+                    program.import_("typing.Optional", True)
+                    proptype = f"Mapped[Optional[{sqltype.mapped_pytype}]]"
+                else:
+                    proptype = f"Mapped[{sqltype.mapped_pytype}]"
                 propvalargs: list[expr.Expr] = [expr.ExprIdent(sqltype.type)]
                 if prop.db.is_primary_key:

{sera_2-1.11.2 → sera_2-1.12.0}/sera/make/make_typescript_model.py RENAMED Viewed

@@ -75,6 +75,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # use id type alias
                     tstype = TsTypeWithDep(f"{cls.name}Id")
+                if prop.is_optional:
+                    # convert type to optional
+                    tstype = tstype.as_optional_type()
                 deser_args.append(
                     (
                         expr.ExprIdent(propname),
@@ -95,6 +99,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     )
                     if prop.cardinality.is_star_to_many():
                         tstype = tstype.as_list_type()
+                    elif prop.is_optional:
+                        # convert type to optional only if it isn't a list
+                        tstype = tstype.as_optional_type()
                     deser_args.append(
                         (
                             expr.ExprIdent(propname),
@@ -134,6 +141,9 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             )
                         )
                     else:
+                        if prop.is_optional:
+                            # convert type to optional only if it isn't a list
+                            tstype = tstype.as_optional_type()
                         deser_args.append(
                             (
                                 expr.ExprIdent(propname),
@@ -270,6 +280,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         create_args = []
         update_args = []
         ser_args = []
+        to_record_args = []
         update_field_funcs: list[Callable[[AST], Any]] = []
         prop2tsname = {}
@@ -329,6 +340,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     # for none id properties, we need to include a type for "invalid" value
                     tstype = _inject_type_for_invalid_value(tstype)
+                if prop.is_optional:
+                    # convert type to optional
+                    tstype = tstype.as_optional_type()
                 for dep in tstype.deps:
                     program.import_(dep, True)
@@ -410,6 +425,41 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         ),
                     )
                 )
+                if not prop.data.is_private:
+                    # private property does not include in the public record
+                    to_record_args.append(
+                        (
+                            expr.ExprIdent(propname),
+                            (
+                                expr.ExprTernary(
+                                    PredefinedFn.attr_getter(
+                                        expr.ExprFuncCall(
+                                            PredefinedFn.attr_getter(
+                                                expr.ExprIdent(draft_validators),
+                                                expr.ExprIdent(propname),
+                                            ),
+                                            [
+                                                PredefinedFn.attr_getter(
+                                                    expr.ExprIdent("this"),
+                                                    expr.ExprIdent(propname),
+                                                )
+                                            ],
+                                        ),
+                                        expr.ExprIdent("isValid"),
+                                    ),
+                                    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)
+                                )
+                            ),
+                        )
+                    )
                 if not (prop.db is not None and prop.db.is_primary_key):
                     # skip observable for primary key as it is not needed
                     observable_args.append(
@@ -438,6 +488,10 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         tstype = tstype.as_list_type()
                         create_propvalue = expr.ExprConstant([])
                     else:
+                        if prop.is_optional:
+                            # convert type to optional - for list type, we don't need to do this
+                            # as we will use empty list as no value
+                            tstype = tstype.as_optional_type()
                         # if target class has an auto-increment primary key, we set a different default value
                         # to be -1 to avoid start from 0
                         target_idprop = prop.target.get_id_property()
@@ -463,6 +517,17 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                             ),
                         )
                     )
+                    if not prop.data.is_private:
+                        # private property does not include in the public record
+                        to_record_args.append(
+                            (
+                                expr.ExprIdent(propname),
+                                PredefinedFn.attr_getter(
+                                    expr.ExprIdent("this"), expr.ExprIdent(propname)
+                                ),
+                            )
+                        )
                 else:
                     # we are going to store the whole object
                     tstype = TsTypeWithDep(
@@ -492,10 +557,66 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                                         expr.ExprIdent("this"), expr.ExprIdent(propname)
                                     ),
                                     lambda item: expr.ExprMethodCall(item, "ser", []),
+                                    (
+                                        (
+                                            lambda item: PredefinedFn.attr_getter(
+                                                expr.ExprFuncCall(
+                                                    PredefinedFn.attr_getter(
+                                                        expr.ExprIdent(
+                                                            draft_validators
+                                                        ),
+                                                        expr.ExprIdent(propname),
+                                                    ),
+                                                    [item],
+                                                ),
+                                                expr.ExprIdent("isValid"),
+                                            )
+                                        )
+                                        if prop.is_optional
+                                        else None
+                                    ),
                                 ),
                             )
                         )
+                        if not prop.data.is_private:
+                            # private property does not include in the public record
+                            to_record_args.append(
+                                (
+                                    expr.ExprIdent(propname),
+                                    PredefinedFn.map_list(
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprIdent("this"),
+                                            expr.ExprIdent(propname),
+                                        ),
+                                        lambda item: expr.ExprMethodCall(
+                                            item, "toRecord", []
+                                        ),
+                                        (
+                                            (
+                                                lambda item: PredefinedFn.attr_getter(
+                                                    expr.ExprFuncCall(
+                                                        PredefinedFn.attr_getter(
+                                                            expr.ExprIdent(
+                                                                draft_validators
+                                                            ),
+                                                            expr.ExprIdent(propname),
+                                                        ),
+                                                        [item],
+                                                    ),
+                                                    expr.ExprIdent("isValid"),
+                                                )
+                                            )
+                                            if prop.is_optional
+                                            else None
+                                        ),
+                                    ),
+                                )
+                            )
                     else:
+                        if prop.is_optional:
+                            # convert type to optional - for list type, we don't need to do this
+                            # as we will use empty list as no value
+                            tstype = tstype.as_optional_type()
                         create_propvalue = expr.ExprMethodCall(
                             expr.ExprIdent(tstype.type),
                             "create",
@@ -510,18 +631,103 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                                 ),
                             ],
                         )
-                        ser_args.append(
-                            (
-                                expr.ExprIdent(prop.name),
-                                expr.ExprMethodCall(
-                                    PredefinedFn.attr_getter(
-                                        expr.ExprIdent("this"), expr.ExprIdent(propname)
+                        if prop.is_optional:
+                            ser_args.append(
+                                (
+                                    expr.ExprIdent(prop.name),
+                                    expr.ExprTernary(
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprFuncCall(
+                                                PredefinedFn.attr_getter(
+                                                    expr.ExprIdent(draft_validators),
+                                                    expr.ExprIdent(propname),
+                                                ),
+                                                [
+                                                    PredefinedFn.attr_getter(
+                                                        expr.ExprIdent("this"),
+                                                        expr.ExprIdent(propname),
+                                                    )
+                                                ],
+                                            ),
+                                            expr.ExprIdent("isValid"),
+                                        ),
+                                        expr.ExprMethodCall(
+                                            PredefinedFn.attr_getter(
+                                                expr.ExprIdent("this"),
+                                                expr.ExprIdent(propname),
+                                            ),
+                                            "ser",
+                                            [],
+                                        ),
+                                        expr.ExprIdent("undefined"),
                                     ),
-                                    "ser",
-                                    [],
-                                ),
+                                )
                             )
-                        )
+                            if not prop.data.is_private:
+                                # private property does not include in the public record
+                                to_record_args.append(
+                                    (
+                                        expr.ExprIdent(propname),
+                                        expr.ExprTernary(
+                                            PredefinedFn.attr_getter(
+                                                expr.ExprFuncCall(
+                                                    PredefinedFn.attr_getter(
+                                                        expr.ExprIdent(
+                                                            draft_validators
+                                                        ),
+                                                        expr.ExprIdent(propname),
+                                                    ),
+                                                    [
+                                                        PredefinedFn.attr_getter(
+                                                            expr.ExprIdent("this"),
+                                                            expr.ExprIdent(propname),
+                                                        )
+                                                    ],
+                                                ),
+                                                expr.ExprIdent("isValid"),
+                                            ),
+                                            expr.ExprMethodCall(
+                                                PredefinedFn.attr_getter(
+                                                    expr.ExprIdent("this"),
+                                                    expr.ExprIdent(propname),
+                                                ),
+                                                "toRecord",
+                                                [],
+                                            ),
+                                            expr.ExprIdent("undefined"),
+                                        ),
+                                    )
+                                )
+                        else:
+                            ser_args.append(
+                                (
+                                    expr.ExprIdent(prop.name),
+                                    expr.ExprMethodCall(
+                                        PredefinedFn.attr_getter(
+                                            expr.ExprIdent("this"),
+                                            expr.ExprIdent(propname),
+                                        ),
+                                        "ser",
+                                        [],
+                                    ),
+                                )
+                            )
+                            if not prop.data.is_private:
+                                # private property does not include in the public record
+                                to_record_args.append(
+                                    (
+                                        expr.ExprIdent(propname),
+                                        expr.ExprMethodCall(
+                                            PredefinedFn.attr_getter(
+                                                expr.ExprIdent("this"),
+                                                expr.ExprIdent(propname),
+                                            ),
+                                            "toRecord",
+                                            [],
+                                        ),
+                                    )
+                                )
                 for dep in tstype.deps:
                     program.import_(
@@ -730,6 +936,20 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                         PredefinedFn.dict(ser_args),
                     ),
                 ),
+                stmt.LineBreak(),
+                lambda ast16: ast16.func(
+                    "toRecord",
+                    [],
+                    expr.ExprIdent(cls.name),
+                    comment="Convert the draft to a normal record. `isValid` must be called first to ensure all data is valid",
+                )(
+                    stmt.ReturnStatement(
+                        expr.ExprNewInstance(
+                            expr.ExprIdent(cls.name),
+                            [PredefinedFn.dict(to_record_args)],
+                        ),
+                    )
+                ),
             ),
             stmt.LineBreak(),
             stmt.TypescriptStatement(

{sera_2-1.11.2 → sera_2-1.12.0}/sera/models/_datatype.py RENAMED Viewed

@@ -97,6 +97,13 @@ class TsTypeWithDep:
             list_type = f"{self.type}[]"
         return TsTypeWithDep(type=list_type, deps=self.deps)
+    def as_optional_type(self) -> TsTypeWithDep:
+        if "undefined" in self.type:
+            raise NotImplementedError(
+                f"Have not handle nested optional yet: {self.type}"
+            )
+        return TsTypeWithDep(type=f"{self.type} | undefined", deps=self.deps)
 @dataclass
 class SQLTypeWithDep: