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

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/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/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/misc/__init__.py

@@ -12,6 +12,7 @@ from sera.misc._utils import (
     load_data_from_dir,
     replay_events,
     to_camel_case,
+    to_kebab_case,
     to_pascal_case,
     to_snake_case,
 )
@@ -34,4 +35,5 @@ __all__ = [
     "load_data_from_dir",
     "replay_events",
     "auto_import",
+    "to_kebab_case",
 ]

sera/misc/_utils.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import inspect
 import re
 from collections import defaultdict
+from curses.ascii import isupper
+from functools import lru_cache
 from importlib import import_module
 from pathlib import Path
 from typing import (
@@ -82,13 +84,16 @@ def import_attr(attr_ident: str):
     return getattr(module, cls)
 
 
-def to_snake_case(camelcase: str) -> str:
+@lru_cache(maxsize=1280)
+def to_snake_case(name: str) -> str:
     """Convert camelCase to snake_case."""
-    snake = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", camelcase)
+    snake = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
     snake = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", snake)
+    snake = snake.replace("-", "_")
     return snake.lower()
 
 
+@lru_cache(maxsize=1280)
 def to_camel_case(snake: str) -> str:
     """Convert snake_case to camelCase."""
     components = snake.split("_")
@@ -99,6 +104,7 @@ def to_camel_case(snake: str) -> str:
     return out
 
 
+@lru_cache(maxsize=1280)
 def to_pascal_case(snake: str) -> str:
     """Convert snake_case to PascalCase."""
     components = snake.split("_")
@@ -109,6 +115,15 @@ def to_pascal_case(snake: str) -> str:
     return out
 
 
+@lru_cache(maxsize=1280)
+def to_kebab_case(name: str) -> str:
+    """Convert a name to kebab-case."""
+    kebab = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1-\2", name)
+    kebab = re.sub(r"([a-z0-9])([A-Z])", r"\1-\2", kebab)
+    kebab = kebab.replace("_", "-")
+    return kebab.lower()
+
+
 def assert_isinstance(x: Any, cls: type[T]) -> T:
     if not isinstance(x, cls):
         raise Exception(f"{type(x)} doesn't match with {type(cls)}")

sera/models/_class.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Optional
 
-from sera.misc import to_snake_case
+from sera.misc import to_kebab_case, to_snake_case
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._property import DataProperty, ObjectProperty
 
@@ -80,4 +80,4 @@ class Class:
 
     def get_tsmodule_name(self) -> str:
         """Get the typescript module name of this class as if there is a typescript module created to store this class only."""
-        return self.name[0].lower() + self.name[1:]
+        return to_kebab_case(self.name)

sera/models/_collection.py

@@ -23,7 +23,7 @@ class DataCollection:
         """Get the python module name of this collection as if there is a python module created to store this collection only."""
         return self.cls.get_pymodule_name()
 
-    def get_queryable_fields(self) -> list[tuple[str, tuple[str, str]]]:
+    def get_queryable_fields(self) -> list[str]:
         """Get the fields of this collection that can be used in a queries."""
         output = []
         for prop in self.cls.properties.values():
@@ -48,17 +48,21 @@ class DataCollection:
                 # This property is a data property or an object property not stored in the database, so we use its name
                 propname = prop.name
 
-            if isinstance(prop, DataProperty):
-                convert_func = prop.datatype.pytype.get_string_conversion_func()
-            else:
-                assert isinstance(prop, ObjectProperty) and prop.target.db is not None
-                target_idprop = prop.target.get_id_property()
-                assert target_idprop is not None
-                convert_func = (
-                    target_idprop.datatype.pytype.get_string_conversion_func()
-                )
+            output.append(propname)
+        return output
+
+    def get_join_queryable_fields(self) -> dict[str, list[str]]:
+        """Get the fields of this collection that can be used in join queries."""
+        output = {}
+        for prop in self.cls.properties.values():
+            if isinstance(prop, DataProperty) and prop.db.foreign_key is not None:
+                # This property is a foreign key, so we add it to the output
+                output[prop.name] = DataCollection(
+                    prop.db.foreign_key
+                ).get_queryable_fields()
+            elif isinstance(prop, ObjectProperty) and prop.target.db is not None:
+                output[prop.name] = DataCollection(prop.target).get_queryable_fields()
 
-            output.append((propname, convert_func))
         return output
 
     def get_service_name(self):

sera/models/_constraints.py

@@ -25,7 +25,7 @@ class Constraint:
             # the UI will ensure to submit it in E.164 format
             return r"msgspec.Meta(pattern=r'^\+[1-9]\d{1,14}$')"
         elif self.name == "email":
-            return r"msgspec.Meta(min_length=3, max_length=254, pattern=r'^[^@]+@[^@]+\.[^@]+$')"
+            return r"msgspec.Meta(min_length=3, max_length=254, pattern=r'^[^@]+@[^@]+\.[a-zA-Z\.]+$')"
         elif self.name == "not_empty":
             return "msgspec.Meta(min_length=1)"
         elif self.name == "username":