sera-2 1.21.2__py3-none-any.whl → 1.24.1__py3-none-any.whl

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,311 +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("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():
@@ -1554,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)
 
@@ -1618,14 +1307,19 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
     if m is not None:
         # This is an array type, add string to the inner type
         inner_type = m.group(1)
+        inner_spectype = assert_not_null(
+            re.match(r"(\(?[a-zA-Z \|]+\)?)(\[\])", tstype.spectype)
+        ).group(1)
         if "string" not in inner_type:
             if inner_type.startswith("(") and inner_type.endswith(")"):
                 # Already has parentheses
                 inner_type = f"{inner_type[:-1]} | string)"
+                inner_spectype = f"{inner_spectype[:-1]} | string)"
             else:
                 # Need to add parentheses
                 inner_type = f"({inner_type} | string)"
-        return TsTypeWithDep(inner_type + "[]", tstype.deps)
+                inner_spectype = f"({inner_spectype} | string)"
+        return TsTypeWithDep(inner_type + "[]", inner_spectype + "[]", tstype.deps)
 
     m = re.match(r"^\(?[a-zA-Z \|]+\)?$", tstype.type)
     if m is not None:
@@ -1633,31 +1327,17 @@ def _inject_type_for_invalid_value(tstype: TsTypeWithDep) -> TsTypeWithDep:
             if tstype.type.startswith("(") and tstype.type.endswith(")"):
                 # Already has parentheses
                 new_type = f"{tstype.type[:-1]} | string)"
+                new_spectype = f"{tstype.spectype[:-1]} | string)"
             else:
                 # Needs parentheses for clarity
                 new_type = f"({tstype.type} | string)"
-            return TsTypeWithDep(new_type, tstype.deps)
+                new_spectype = f"({tstype.spectype} | string)"
+            return TsTypeWithDep(new_type, new_spectype, tstype.deps)
         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")
-    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]: