sera-2 1.23.0__py3-none-any.whl → 1.25.0__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/models/__init__.py

@@ -5,7 +5,13 @@ from sera.models._enum import Enum
 from sera.models._module import App, Module, Package
 from sera.models._multi_lingual_string import MultiLingualString
 from sera.models._parse import parse_schema
-from sera.models._property import Cardinality, DataProperty, ObjectProperty, Property
+from sera.models._property import (
+    Cardinality,
+    DataProperty,
+    IndexType,
+    ObjectProperty,
+    Property,
+)
 from sera.models._schema import Schema
 
 __all__ = [
@@ -14,6 +20,7 @@ __all__ = [
     "Property",
     "DataProperty",
     "ObjectProperty",
+    "IndexType",
     "Class",
     "Cardinality",
     "DataType",

sera/models/_class.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 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
+from sera.models._property import DataProperty, IndexType, ObjectProperty
 
 
 @dataclass(kw_only=True)
@@ -13,6 +13,7 @@ class Index:
     name: str
     columns: list[str]
     unique: bool = False
+    index_type: IndexType = IndexType.DEFAULT
 
 
 @dataclass(kw_only=True)

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/models/_parse.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 from copy import deepcopy
+from operator import index
 from pathlib import Path
 from typing import Sequence
 
@@ -30,6 +31,7 @@ from sera.models._property import (
     ForeignKeyOnDelete,
     ForeignKeyOnUpdate,
     GetSCPropValueFunc,
+    IndexType,
     ObjectPropDBInfo,
     ObjectProperty,
     PropDataAttrs,
@@ -91,13 +93,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:
@@ -146,7 +152,7 @@ def _parse_property(
 
     assert isinstance(prop, dict), prop
     if "datatype" in prop:
-        return DataProperty(
+        return_prop = DataProperty(
             name=prop_name,
             label=_parse_multi_lingual_string(prop.get("label", prop_name)),
             description=_parse_multi_lingual_string(prop.get("desc", "")),
@@ -160,6 +166,9 @@ def _parse_property(
                     is_indexed=db.get("is_indexed", False)
                     or db.get("is_unique", False)
                     or db.get("is_primary_key", False),
+                    index_type=(
+                        IndexType(db["index_type"]) if "index_type" in db else None
+                    ),
                     foreign_key=schema.classes.get(db.get("foreign_key")),
                 )
                 if "db" in prop
@@ -169,6 +178,10 @@ def _parse_property(
             default_value=_parse_default_value(prop.get("default_value", None)),
             default_factory=_parse_default_factory(prop.get("default_factory", None)),
         )
+        if return_prop.db is not None and return_prop.db.is_indexed:
+            if return_prop.db.index_type is None:
+                return_prop.db.index_type = IndexType.DEFAULT
+        return return_prop
 
     assert "target" in prop, prop
     return ObjectProperty(

sera/models/_property.py

@@ -16,6 +16,12 @@ if TYPE_CHECKING:
     from sera.models._class import Class
 
 
+class IndexType(str, Enum):
+    DEFAULT = "default"
+    POSTGRES_FTS_SEVI = "postgres_fts_sevi"
+    POSTGRES_TRIGRAM = "postgres_trigram"
+
+
 class ForeignKeyOnDelete(str, Enum):
     CASCADE = "cascade"
     SET_NULL = "set null"
@@ -150,6 +156,8 @@ class DataPropDBInfo:
     is_unique: bool = False
     # whether this property is indexed or not
     is_indexed: bool = False
+    # type of the index if it is indexed --- if is_indexed is True, this must be not None
+    index_type: Optional[IndexType] = None
     # this is used in conjunction with is_primary_key = True for the case of
     # extending a table with frequently updated properties. The value for the `foreign_key`
     # will be a target class. The cardinality is one-to-one, on target class deletion,

sera/typing.py

@@ -39,4 +39,5 @@ GLOBAL_IDENTS = {
     "UNSET": "sera.typing.UNSET",
     "ForeignKey": "sqlalchemy.ForeignKey",
     "Optional": "typing.Optional",
+    "text": "sqlalchemy.text",
 }

{sera_2-1.23.0.dist-info → sera_2-1.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sera-2
-Version: 1.23.0
+Version: 1.25.0
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com
@@ -8,8 +8,9 @@ Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: black (==25.1.0)
-Requires-Dist: codegen-2 (>=2.14.0,<3.0.0)
+Requires-Dist: codegen-2 (>=2.15.1,<3.0.0)
 Requires-Dist: graph-wrapper (>=1.7.3,<2.0.0)
 Requires-Dist: isort (==6.0.1)
 Requires-Dist: litestar (>=2.15.1,<3.0.0)