sera-2 1.23.0__tar.gz → 1.24.1__tar.gz

{sera_2-1.23.0 → sera_2-1.24.1}/PKG-INFO

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

{sera_2-1.23.0 → sera_2-1.24.1}/pyproject.toml

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

{sera_2-1.23.0 → sera_2-1.24.1}/sera/make/make_app.py

@@ -7,6 +7,7 @@ from typing import Annotated
 
 from codegen.models import DeferredVar, PredefinedFn, Program, expr, stmt
 from loguru import logger
+
 from sera.make.make_python_api import make_python_api
 from sera.make.make_python_model import (
     make_python_data_model,
@@ -14,10 +15,8 @@ from sera.make.make_python_model import (
     make_python_relational_model,
 )
 from sera.make.make_python_services import make_python_service_structure
-from sera.make.make_typescript_model import (
-    make_typescript_data_model,
-    make_typescript_enum,
-)
+from sera.make.make_typescript_model import make_typescript_data_model
+from sera.make.ts_frontend.make_enums import make_typescript_enums
 from sera.misc import Formatter
 from sera.models import App, DataCollection, parse_schema
 from sera.typing import Language
@@ -170,7 +169,7 @@ def make_app(
         # generate services
         make_python_service_structure(app, collections)
     elif language == Language.Typescript:
-        make_typescript_enum(schema, app.models)
+        make_typescript_enums(schema, app.models)
         make_typescript_data_model(schema, app.models)
 
     Formatter.get_instance().process()

{sera_2-1.23.0 → sera_2-1.24.1}/sera/make/make_typescript_model.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 
 from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
 from codegen.models.var import DeferredVar
 from loguru import logger
 
+from sera.make.ts_frontend.make_class_schema import make_class_schema
+from sera.make.ts_frontend.misc import TS_GLOBAL_IDENTS, get_normalizer
 from sera.misc import (
     assert_isinstance,
     assert_not_null,
@@ -26,13 +28,6 @@ from sera.models import (
 )
 from sera.typing import is_set
 
-TS_GLOBAL_IDENTS = {
-    "normalizers.normalizeNumber": "sera-db.normalizers",
-    "normalizers.normalizeOptionalNumber": "sera-db.normalizers",
-    "normalizers.normalizeDate": "sera-db.normalizers",
-    "normalizers.normalizeOptionalDate": "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."""
@@ -440,13 +435,12 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
                     if tstype.type in idprop_aliases:
                         create_propvalue = idprop_aliases[tstype.type].get_default()
                     elif tstype.type in schema.enums:
-                        enum_value = next(
+                        enum_value_name = next(
                             iter(schema.enums[tstype.type].values.values())
-                        ).value
-                        # TODO: handle enum value integer
-                        assert isinstance(enum_value, str)
+                        ).name
+                        assert isinstance(enum_value_name, str), enum_value_name
                         create_propvalue = expr.ExprIdent(
-                            tstype.type + "." + enum_value
+                            tstype.type + "." + enum_value_name
                         )
                     else:
                         create_propvalue = tstype.get_default()
@@ -1194,323 +1188,6 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
 
         outmod.write(program)
 
-    def make_definition(cls: Class, pkg: Package):
-        """Make schema definition for the class in frontend so that we can generate components"""
-        if not cls.is_public:
-            # skip classes that are not public
-            return
-
-        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.
-            # if prop.data.is_private:
-            #     # skip private fields as this is for APIs exchange
-            #     continue
-            tspropname = to_camel_case(prop.name)
-            pypropname = prop.name
-            if isinstance(prop, ObjectProperty) and prop.target.db is not None:
-                # this is a database object, we append id to the property name
-                tspropname = tspropname + "Id"
-                pypropname = prop.name + "_id"
-
-            tsprop = {}
-
-            if isinstance(prop, DataProperty):
-                tstype = prop.get_data_model_datatype().get_typescript_type()
-                # for schema definition, we need to use the original type, not the type alias
-                # if prop.name == idprop.name:
-                #     # use id type alias
-                #     tstype = TsTypeWithDep(f"{cls.name}Id")
-                for dep in tstype.deps:
-                    program.import_(dep, True)
-                tsprop = [
-                    (
-                        expr.ExprIdent("datatype"),
-                        (
-                            expr.ExprConstant(tstype.spectype)
-                            if tstype.type not in schema.enums
-                            else expr.ExprConstant("enum")
-                        ),
-                    ),
-                    *(
-                        [(expr.ExprIdent("enumType"), expr.ExprIdent(tstype.type))]
-                        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(
-                            not prop.is_optional
-                            and prop.default_value is None
-                            and prop.default_factory is None
-                        ),
-                    ),
-                ]
-
-                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(tspropname), norm_func))
-            else:
-                assert isinstance(prop, ObjectProperty)
-                if prop.target.db is not None:
-                    # this class is stored in the database, we store the id instead
-                    tstype = (
-                        assert_not_null(prop.target.get_id_property())
-                        .get_data_model_datatype()
-                        .get_typescript_type()
-                    )
-                else:
-                    # we are going to store the whole object
-                    tstype = TsTypeWithDep(
-                        type=prop.target.name,
-                        spectype=prop.target.name,
-                        deps=[
-                            f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}"
-                        ],
-                    )
-
-                # we don't store the type itself, but just the name of the type
-                # so not need to import the dependency
-                # if tstype.dep is not None:
-                #     program.import_(
-                #         tstype.dep,
-                #         True,
-                #     )
-
-                tsprop = [
-                    (
-                        expr.ExprIdent("targetClass"),
-                        expr.ExprConstant(prop.target.name),
-                    ),
-                    (
-                        expr.ExprIdent("datatype"),
-                        expr.ExprConstant(
-                            tstype.spectype
-                            if prop.target.db is not None
-                            else "undefined"
-                        ),
-                    ),
-                    (
-                        expr.ExprIdent("cardinality"),
-                        expr.ExprConstant(prop.cardinality.value),
-                    ),
-                    (
-                        expr.ExprIdent("isEmbedded"),
-                        expr.ExprConstant(prop.target.db is None),
-                    ),
-                    (
-                        expr.ExprIdent("isRequired"),
-                        expr.ExprConstant(not prop.is_optional),
-                    ),
-                ]
-
-            prop_defs.append(
-                (
-                    prop,
-                    expr.ExprIdent(tspropname),
-                    PredefinedFn.dict(
-                        [
-                            (expr.ExprIdent("name"), expr.ExprConstant(pypropname)),
-                            (expr.ExprIdent("tsName"), expr.ExprConstant(tspropname)),
-                            (
-                                expr.ExprIdent("updateFuncName"),
-                                expr.ExprConstant(f"update{to_pascal_case(prop.name)}"),
-                            ),
-                            (
-                                expr.ExprIdent("label"),
-                                expr.ExprConstant(prop.label.to_dict()),
-                            ),
-                            (
-                                expr.ExprIdent("description"),
-                                (
-                                    expr.ExprConstant(prop.description.to_dict())
-                                    if not prop.description.is_empty()
-                                    else expr.ExprConstant("undefined")
-                                ),
-                            ),
-                            (
-                                expr.ExprIdent("constraints"),
-                                PredefinedFn.list(
-                                    [
-                                        expr.ExprConstant(
-                                            constraint.get_typescript_constraint()
-                                        )
-                                        for constraint in prop.data.constraints
-                                    ]
-                                ),
-                            ),
-                        ]
-                        + tsprop
-                    ),
-                )
-            )
-
-        for type in ["ObjectProperty", "DataProperty"]:
-            program.import_(f"sera-db.{type}", True)
-        if cls.db is not None:
-            program.import_(f"sera-db.Schema", True)
-        else:
-            program.import_(f"sera-db.EmbeddedSchema", True)
-
-        program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}", True)
-        program.import_(
-            f"@.models.{pkg.dir.name}.Draft{cls.name}.Draft{cls.name}", True
-        )
-        program.import_(
-            f"@.models.{pkg.dir.name}.Draft{cls.name}.draft{cls.name}Validators", True
-        )
-        if cls.db is not None:
-            program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id", True)
-
-        program.root(
-            stmt.LineBreak(),
-            stmt.TypescriptStatement(
-                f"export type {cls.name}SchemaType = "
-                + PredefinedFn.dict(
-                    (
-                        [
-                            (expr.ExprIdent("id"), expr.ExprIdent(f"{cls.name}Id")),
-                        ]
-                        if cls.db is not None
-                        else []
-                    )
-                    + [
-                        (
-                            expr.ExprIdent("publicProperties"),
-                            expr.ExprIdent(
-                                " | ".join(
-                                    [
-                                        expr.ExprConstant(
-                                            to_camel_case(prop.name) + "Id"
-                                            if isinstance(prop, ObjectProperty)
-                                            and prop.target.db is not None
-                                            else to_camel_case(prop.name)
-                                        ).to_typescript()
-                                        for prop in cls.properties.values()
-                                        if not prop.data.is_private
-                                    ]
-                                )
-                            ),
-                        ),
-                        (
-                            expr.ExprIdent("allProperties"),
-                            expr.ExprIdent(
-                                f"{cls.name}SchemaType['publicProperties']"
-                                + (
-                                    " | "
-                                    + " | ".join(
-                                        [
-                                            expr.ExprConstant(
-                                                to_camel_case(prop.name)
-                                            ).to_typescript()
-                                            for prop in cls.properties.values()
-                                            if prop.data.is_private
-                                        ]
-                                    )
-                                    if any(
-                                        prop.data.is_private
-                                        for prop in cls.properties.values()
-                                    )
-                                    else ""
-                                )
-                            ),
-                        ),
-                        (
-                            expr.ExprIdent("cls"),
-                            expr.ExprIdent(cls.name),
-                        ),
-                        (
-                            expr.ExprIdent("draftCls"),
-                            expr.ExprIdent(f"Draft{cls.name}"),
-                        ),
-                    ]
-                ).to_typescript()
-                + ";",
-            ),
-            stmt.LineBreak(),
-            stmt.TypescriptStatement(
-                f"const publicProperties: Record<{cls.name}SchemaType['publicProperties'], DataProperty | ObjectProperty> = "
-                + PredefinedFn.dict(
-                    [
-                        (prop_name, prop_def)
-                        for prop, prop_name, prop_def in prop_defs
-                        if not prop.data.is_private
-                    ]
-                ).to_typescript()
-                + ";"
-            ),
-            stmt.LineBreak(),
-            stmt.TypescriptStatement(
-                (
-                    f"export const {cls.name}Schema: Schema<{cls.name}SchemaType['id'], {cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties'], {cls.name}SchemaType> = "
-                    if cls.db is not None
-                    else f"export const {cls.name}Schema: EmbeddedSchema<{cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties']> = "
-                )
-                + PredefinedFn.dict(
-                    [
-                        (
-                            expr.ExprIdent("publicProperties"),
-                            expr.ExprIdent("publicProperties"),
-                        ),
-                        (
-                            expr.ExprIdent("allProperties"),
-                            expr.ExprIdent(
-                                "{ ...publicProperties, "
-                                + ", ".join(
-                                    [
-                                        f"{prop_name.to_typescript()}: {prop_def.to_typescript()}"
-                                        for prop, prop_name, prop_def in prop_defs
-                                        if prop.data.is_private
-                                    ]
-                                )
-                                + "}"
-                            ),
-                        ),
-                        (
-                            expr.ExprIdent("validators"),
-                            expr.ExprIdent(f"draft{cls.name}Validators"),
-                        ),
-                        (
-                            expr.ExprIdent("normalizers"),
-                            PredefinedFn.dict(prop_normalizers),
-                        ),
-                    ]
-                    + (
-                        [
-                            (
-                                expr.ExprIdent("primaryKey"),
-                                expr.ExprConstant(
-                                    assert_not_null(cls.get_id_property()).name
-                                ),
-                            )
-                        ]
-                        if cls.db is not None
-                        else []
-                    )
-                ).to_typescript()
-                + ";"
-            ),
-        )
-        pkg.module(cls.name + "Schema").write(program)
-
     def make_index(pkg: Package):
         outmod = pkg.module("index")
         if outmod.exists():
@@ -1566,7 +1243,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         make_draft(cls, pkg)
         make_query_processor(cls, pkg)
         make_table(cls, pkg)
-        make_definition(cls, pkg)
+        make_class_schema(schema, cls, pkg)
 
         make_index(pkg)
 
@@ -1661,22 +1338,6 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
     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")
-    if tstype.type == "Date":
-        return import_helper.use("normalizers.normalizeDate")
-    if tstype.type == "Date | undefined":
-        return import_helper.use("normalizers.normalizeOptionalDate")
-
-    assert "number" not in tstype.type, tstype.type
-    return None
-
-
 def get_norm_func(
     tstype: TsTypeWithDep, import_helper: ImportHelper
 ) -> Callable[[expr.Expr], expr.Expr]:

sera_2-1.24.1/sera/make/ts_frontend/make_class_schema.py

@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+from codegen.models import ImportHelper, PredefinedFn, Program, expr, stmt
+
+from sera.make.ts_frontend.misc import TS_GLOBAL_IDENTS, get_normalizer
+from sera.misc import assert_not_null, to_camel_case, to_pascal_case
+from sera.models import (
+    Class,
+    DataProperty,
+    Enum,
+    ObjectProperty,
+    Package,
+    Schema,
+    TsTypeWithDep,
+)
+from sera.typing import is_set
+
+
+def make_class_schema(schema: Schema, cls: Class, pkg: Package):
+    """Make schema definition for the class in frontend so that components can use this information select
+    appropriate components to display or edit the data.
+
+    Args:
+        schema: The overall schema of the application, which contains all classes & enums
+        cls: The class that we want to generate the schema
+        pkg: The output package (directory) for the class in the `@.models` package. For example, if the
+            class is `User`, then the package would be `src/models/user`.
+
+    Returns:
+        This function do not return anything as it writes the schema directly to a file.
+    """
+    if not cls.is_public:
+        # skip classes that are not public
+        return
+
+    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.
+        # if prop.data.is_private:
+        #     # skip private fields as this is for APIs exchange
+        #     continue
+        tspropname = to_camel_case(prop.name)
+        pypropname = prop.name
+        if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+            # this is a database object, we append id to the property name
+            tspropname = tspropname + "Id"
+            pypropname = prop.name + "_id"
+
+        tsprop = {}
+
+        if isinstance(prop, DataProperty):
+            tstype = prop.get_data_model_datatype().get_typescript_type()
+            # for schema definition, we need to use the original type, not the type alias
+            # if prop.name == idprop.name:
+            #     # use id type alias
+            #     tstype = TsTypeWithDep(f"{cls.name}Id")
+            for dep in tstype.deps:
+                program.import_(dep, True)
+            tsprop = [
+                (
+                    expr.ExprIdent("datatype"),
+                    (
+                        expr.ExprConstant(tstype.spectype)
+                        if tstype.type not in schema.enums
+                        else expr.ExprConstant("enum")
+                    ),
+                ),
+                *(
+                    [
+                        (
+                            expr.ExprIdent("enumType"),
+                            export_enum_info(program, schema.enums[tstype.type]),
+                        )
+                    ]
+                    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(
+                        not prop.is_optional
+                        and prop.default_value is None
+                        and prop.default_factory is None
+                    ),
+                ),
+            ]
+
+            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(tspropname), norm_func))
+        else:
+            assert isinstance(prop, ObjectProperty)
+            if prop.target.db is not None:
+                # this class is stored in the database, we store the id instead
+                tstype = (
+                    assert_not_null(prop.target.get_id_property())
+                    .get_data_model_datatype()
+                    .get_typescript_type()
+                )
+            else:
+                # we are going to store the whole object
+                tstype = TsTypeWithDep(
+                    type=prop.target.name,
+                    spectype=prop.target.name,
+                    deps=[
+                        f"@.models.{prop.target.get_tsmodule_name()}.{prop.target.name}.{prop.target.name}"
+                    ],
+                )
+
+            # we don't store the type itself, but just the name of the type
+            # so not need to import the dependency
+            # if tstype.dep is not None:
+            #     program.import_(
+            #         tstype.dep,
+            #         True,
+            #     )
+
+            tsprop = [
+                (
+                    expr.ExprIdent("targetClass"),
+                    expr.ExprConstant(prop.target.name),
+                ),
+                (
+                    expr.ExprIdent("datatype"),
+                    expr.ExprConstant(
+                        tstype.spectype if prop.target.db is not None else "undefined"
+                    ),
+                ),
+                (
+                    expr.ExprIdent("cardinality"),
+                    expr.ExprConstant(prop.cardinality.value),
+                ),
+                (
+                    expr.ExprIdent("isEmbedded"),
+                    expr.ExprConstant(prop.target.db is None),
+                ),
+                (
+                    expr.ExprIdent("isRequired"),
+                    expr.ExprConstant(not prop.is_optional),
+                ),
+            ]
+
+        prop_defs.append(
+            (
+                prop,
+                expr.ExprIdent(tspropname),
+                PredefinedFn.dict(
+                    [
+                        (expr.ExprIdent("name"), expr.ExprConstant(pypropname)),
+                        (expr.ExprIdent("tsName"), expr.ExprConstant(tspropname)),
+                        (
+                            expr.ExprIdent("updateFuncName"),
+                            expr.ExprConstant(f"update{to_pascal_case(prop.name)}"),
+                        ),
+                        (
+                            expr.ExprIdent("label"),
+                            expr.ExprConstant(prop.label.to_dict()),
+                        ),
+                        (
+                            expr.ExprIdent("description"),
+                            (
+                                expr.ExprConstant(prop.description.to_dict())
+                                if not prop.description.is_empty()
+                                else expr.ExprConstant("undefined")
+                            ),
+                        ),
+                        (
+                            expr.ExprIdent("constraints"),
+                            PredefinedFn.list(
+                                [
+                                    expr.ExprConstant(
+                                        constraint.get_typescript_constraint()
+                                    )
+                                    for constraint in prop.data.constraints
+                                ]
+                            ),
+                        ),
+                    ]
+                    + tsprop
+                ),
+            )
+        )
+
+    for type in ["ObjectProperty", "DataProperty"]:
+        program.import_(f"sera-db.{type}", True)
+    if cls.db is not None:
+        program.import_(f"sera-db.Schema", True)
+    else:
+        program.import_(f"sera-db.EmbeddedSchema", True)
+
+    program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}", True)
+    program.import_(f"@.models.{pkg.dir.name}.Draft{cls.name}.Draft{cls.name}", True)
+    program.import_(
+        f"@.models.{pkg.dir.name}.Draft{cls.name}.draft{cls.name}Validators", True
+    )
+    if cls.db is not None:
+        program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}Id", True)
+
+    program.root(
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"export type {cls.name}SchemaType = "
+            + PredefinedFn.dict(
+                (
+                    [
+                        (expr.ExprIdent("id"), expr.ExprIdent(f"{cls.name}Id")),
+                    ]
+                    if cls.db is not None
+                    else []
+                )
+                + [
+                    (
+                        expr.ExprIdent("publicProperties"),
+                        expr.ExprIdent(
+                            " | ".join(
+                                [
+                                    expr.ExprConstant(
+                                        to_camel_case(prop.name) + "Id"
+                                        if isinstance(prop, ObjectProperty)
+                                        and prop.target.db is not None
+                                        else to_camel_case(prop.name)
+                                    ).to_typescript()
+                                    for prop in cls.properties.values()
+                                    if not prop.data.is_private
+                                ]
+                            )
+                        ),
+                    ),
+                    (
+                        expr.ExprIdent("allProperties"),
+                        expr.ExprIdent(
+                            f"{cls.name}SchemaType['publicProperties']"
+                            + (
+                                " | "
+                                + " | ".join(
+                                    [
+                                        expr.ExprConstant(
+                                            to_camel_case(prop.name)
+                                        ).to_typescript()
+                                        for prop in cls.properties.values()
+                                        if prop.data.is_private
+                                    ]
+                                )
+                                if any(
+                                    prop.data.is_private
+                                    for prop in cls.properties.values()
+                                )
+                                else ""
+                            )
+                        ),
+                    ),
+                    (
+                        expr.ExprIdent("cls"),
+                        expr.ExprIdent(cls.name),
+                    ),
+                    (
+                        expr.ExprIdent("draftCls"),
+                        expr.ExprIdent(f"Draft{cls.name}"),
+                    ),
+                ]
+            ).to_typescript()
+            + ";",
+        ),
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"const publicProperties: Record<{cls.name}SchemaType['publicProperties'], DataProperty | ObjectProperty> = "
+            + PredefinedFn.dict(
+                [
+                    (prop_name, prop_def)
+                    for prop, prop_name, prop_def in prop_defs
+                    if not prop.data.is_private
+                ]
+            ).to_typescript()
+            + ";"
+        ),
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            (
+                f"export const {cls.name}Schema: Schema<{cls.name}SchemaType['id'], {cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties'], {cls.name}SchemaType> = "
+                if cls.db is not None
+                else f"export const {cls.name}Schema: EmbeddedSchema<{cls.name}SchemaType['cls'], {cls.name}SchemaType['draftCls'], {cls.name}SchemaType['publicProperties'], {cls.name}SchemaType['allProperties']> = "
+            )
+            + PredefinedFn.dict(
+                [
+                    (
+                        expr.ExprIdent("publicProperties"),
+                        expr.ExprIdent("publicProperties"),
+                    ),
+                    (
+                        expr.ExprIdent("allProperties"),
+                        expr.ExprIdent(
+                            "{ ...publicProperties, "
+                            + ", ".join(
+                                [
+                                    f"{prop_name.to_typescript()}: {prop_def.to_typescript()}"
+                                    for prop, prop_name, prop_def in prop_defs
+                                    if prop.data.is_private
+                                ]
+                            )
+                            + "}"
+                        ),
+                    ),
+                    (
+                        expr.ExprIdent("validators"),
+                        expr.ExprIdent(f"draft{cls.name}Validators"),
+                    ),
+                    (
+                        expr.ExprIdent("normalizers"),
+                        PredefinedFn.dict(prop_normalizers),
+                    ),
+                ]
+                + (
+                    [
+                        (
+                            expr.ExprIdent("primaryKey"),
+                            expr.ExprConstant(
+                                assert_not_null(cls.get_id_property()).name
+                            ),
+                        )
+                    ]
+                    if cls.db is not None
+                    else []
+                )
+            ).to_typescript()
+            + ";"
+        ),
+    )
+    pkg.module(cls.name + "Schema").write(program)
+
+
+def export_enum_info(program: Program, enum: Enum) -> expr.Expr:
+    """Export enum information to
+
+    ```
+    {
+        type: <EnumType>,
+        label: { [value]: MultiLingualString },
+        description: { [value]: MultiLingualString }
+    }
+    ```
+    """
+    for key in ["Label", "Description"]:
+        program.import_(f"@.models.enums.{enum.name}{key}", True)
+
+    return PredefinedFn.dict(
+        [
+            (expr.ExprIdent("type"), expr.ExprIdent(enum.name)),
+            (expr.ExprIdent("label"), expr.ExprIdent(enum.name + "Label")),
+            (expr.ExprIdent("description"), expr.ExprIdent(enum.name + "Description")),
+        ]
+    )

sera_2-1.24.1/sera/make/ts_frontend/make_enums.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Callable
+
+from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
+from codegen.models.var import DeferredVar
+from loguru import logger
+
+from sera.make.ts_frontend.make_class_schema import make_class_schema
+from sera.make.ts_frontend.misc import TS_GLOBAL_IDENTS, get_normalizer
+from sera.misc import (
+    assert_isinstance,
+    assert_not_null,
+    identity,
+    to_camel_case,
+    to_pascal_case,
+    to_snake_case,
+)
+from sera.models import (
+    Class,
+    DataProperty,
+    Enum,
+    ObjectProperty,
+    Package,
+    Schema,
+    TsTypeWithDep,
+)
+from sera.typing import is_set
+
+
+def make_typescript_enums(schema: Schema, target_pkg: Package):
+    """Make typescript enum for the schema"""
+    enum_pkg = target_pkg.pkg("enums")
+
+    for enum in schema.enums.values():
+        make_enum(enum, enum_pkg)
+
+    program = Program()
+    for enum in schema.enums.values():
+        program.import_(f"@.models.enums.{enum.get_tsmodule_name()}.{enum.name}", True)
+        program.import_(
+            f"@.models.enums.{enum.get_tsmodule_name()}.{enum.name}Label", True
+        )
+        program.import_(
+            f"@.models.enums.{enum.get_tsmodule_name()}.{enum.name}Description", True
+        )
+
+    program.root(
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            "export { "
+            + ", ".join([enum.name for enum in schema.enums.values()])
+            + ","
+            + ", ".join([enum.name + "Label" for enum in schema.enums.values()])
+            + ","
+            + ", ".join([enum.name + "Description" for enum in schema.enums.values()])
+            + "};"
+        ),
+    )
+    enum_pkg.module("index").write(program)
+
+
+def make_enum(enum: Enum, pkg: Package):
+    program = Program()
+    program.root(
+        stmt.LineBreak(),
+        lambda ast: ast.class_like("enum", enum.name)(
+            *[
+                stmt.DefEnumValueStatement(
+                    name=value.name,
+                    value=expr.ExprConstant(value.value),
+                )
+                for value in enum.values.values()
+            ]
+        ),
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"export const {enum.name}Label = "
+            + PredefinedFn.dict(
+                [
+                    (
+                        expr.ExprConstant(value.value),
+                        expr.ExprConstant(value.label.to_dict()),
+                    )
+                    for value in enum.values.values()
+                ]
+            ).to_typescript()
+        ),
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"export const {enum.name}Description = "
+            + PredefinedFn.dict(
+                [
+                    (
+                        expr.ExprConstant(value.value),
+                        expr.ExprConstant(value.description.to_dict()),
+                    )
+                    for value in enum.values.values()
+                ]
+            ).to_typescript()
+        ),
+    )
+    pkg.module(enum.get_tsmodule_name()).write(program)

sera_2-1.24.1/sera/make/ts_frontend/misc.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
+
+from sera.models import (
+    Class,
+    DataProperty,
+    Enum,
+    ObjectProperty,
+    Package,
+    Schema,
+    TsTypeWithDep,
+)
+
+TS_GLOBAL_IDENTS = {
+    "normalizers.normalizeNumber": "sera-db.normalizers",
+    "normalizers.normalizeOptionalNumber": "sera-db.normalizers",
+    "normalizers.normalizeDate": "sera-db.normalizers",
+    "normalizers.normalizeOptionalDate": "sera-db.normalizers",
+}
+
+
+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")
+    if tstype.type == "Date":
+        return import_helper.use("normalizers.normalizeDate")
+    if tstype.type == "Date | undefined":
+        return import_helper.use("normalizers.normalizeOptionalDate")
+
+    assert "number" not in tstype.type, tstype.type
+    return None

{sera_2-1.23.0 → sera_2-1.24.1}/sera/models/_enum.py

@@ -11,6 +11,7 @@ from sera.models._multi_lingual_string import MultiLingualString
 class EnumValue:
     name: str
     value: str | int
+    label: MultiLingualString
     description: MultiLingualString
 
 
@@ -44,7 +45,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 to_kebab_case(self.name)
+        return self.name
 
     def is_str_enum(self) -> bool:
         """Check if this enum is a string enum."""

{sera_2-1.23.0 → sera_2-1.24.1}/sera/models/_parse.py

@@ -91,13 +91,17 @@ def _parse_enum(schema: Schema, enum_name: str, enum: dict) -> Enum:
     for k, v in enum.items():
         if isinstance(v, (str, int)):
             values[k] = EnumValue(
-                name=k, value=v, description=MultiLingualString.en("")
+                name=k,
+                value=v,
+                label=MultiLingualString.en(""),
+                description=MultiLingualString.en(""),
             )
         else:
             try:
                 values[k] = EnumValue(
                     name=k,
                     value=v["value"],
+                    label=_parse_multi_lingual_string(v.get("label", "")),
                     description=_parse_multi_lingual_string(v.get("desc", "")),
                 )
             except KeyError as e: