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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sera-2
-Version: 1.24.1
+Version: 1.26.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)

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sera-2"
-version = "1.24.1"
+version = "1.26.0"
 description = ""
 authors = ["Binh Vu <bvu687@gmail.com>"]
 readme = "README.md"
@@ -9,7 +9,7 @@ repository = "https://github.com/binh-vu/sera"
 
 [tool.poetry.dependencies]
 python = "^3.12"
-codegen-2 = "^2.14.0"
+codegen-2 = "^2.15.1"
 msgspec = "^0.19.0"
 litestar = "^2.15.1"
 loguru = "^0.7.0"

{sera_2-1.24.1 → sera_2-1.26.0}/sera/libs/base_service.py

@@ -10,8 +10,8 @@ from sqlalchemy.orm import contains_eager, load_only
 
 from sera.libs.base_orm import BaseORM
 from sera.libs.search_helper import Query, QueryOp
-from sera.misc import assert_not_null, to_snake_case
-from sera.models import Cardinality, Class, DataProperty, ObjectProperty
+from sera.misc import assert_isinstance, assert_not_null, to_snake_case
+from sera.models import Cardinality, Class, DataProperty, IndexType, ObjectProperty
 
 R = TypeVar("R", bound=BaseORM)
 ID = TypeVar("ID")  # ID of a class
@@ -20,6 +20,7 @@ SqlResult = TypeVar("SqlResult", bound=Result)
 
 class QueryResult(NamedTuple, Generic[R]):
     records: Sequence[R]
+    extra_columns: Mapping[str, Sequence]
     total: Optional[int]
 
 
@@ -36,6 +37,7 @@ class BaseAsyncService(Generic[ID, R]):
         self._cls_id_prop = getattr(self.orm_cls, self.id_prop.name)
         self.is_id_auto_increment = assert_not_null(self.id_prop.db).is_auto_increment
 
+        # mapping from property name to ORM class for object properties
         self.prop2orm: dict[str, type] = {
             prop.name: orm_classes[prop.target.name]
             for prop in cls.properties.values()
@@ -103,15 +105,15 @@ class BaseAsyncService(Generic[ID, R]):
                 # A -> B is either 1:1 or N:1, we will store the foreign key is in A
                 # .join(B, A.<foreign_key> == B.id)
                 self.join_clauses[prop.name] = [
-                    {
-                        "class": target_tbl,
-                        "condition": getattr(
-                            target_tbl,
-                            assert_not_null(target_cls.get_id_property()).name,
-                        )
-                        == getattr(self.orm_cls, source_fk),
-                        "contains_eager": getattr(self.orm_cls, source_relprop),
-                    },
+                    #     {
+                    #         "class": target_tbl,
+                    #         "condition": getattr(
+                    #             target_tbl,
+                    #             assert_not_null(target_cls.get_id_property()).name,
+                    #         )
+                    #         == getattr(self.orm_cls, source_fk),
+                    #         "contains_eager": getattr(self.orm_cls, source_relprop),
+                    #     },
                 ]
 
     @classmethod
@@ -135,6 +137,7 @@ class BaseAsyncService(Generic[ID, R]):
             session: The database session
         """
         q = self._select()
+        extra_cols = []
 
         if len(query.fields) > 0:
             q = q.options(
@@ -195,12 +198,60 @@ class BaseAsyncService(Generic[ID, R]):
                 q = q.where(~getattr(self.orm_cls, clause.field).in_(clause.value))
             else:
                 assert clause.op == QueryOp.fuzzy
-                # Assuming fuzzy search is implemented as a full-text search
-                q = q.where(
-                    func.to_tsvector(getattr(self.orm_cls, clause.field)).match(
-                        clause.value
-                    )
+                clause_prop = self.cls.properties[clause.field]
+                assert (
+                    isinstance(clause_prop, DataProperty) and clause_prop.db is not None
                 )
+                clause_orm_field = getattr(self.orm_cls, clause.field)
+                extra_cols.append(f"{clause.field}_score")
+
+                if clause_prop.db.index_type == IndexType.POSTGRES_FTS_SEVI:
+                    # fuzzy search is implemented using Postgres Full-Text Search
+                    # sevi is a custom text search configuration that we defined in `configs/postgres-fts.sql`
+                    q = q.where(
+                        func.to_tsvector("sevi", clause_orm_field).bool_op("@@")(
+                            func.plainto_tsquery("sevi", clause.value)
+                        )
+                    )
+                    # TODO: figure out which rank function is better
+                    # https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-RANKING
+                    q = q.order_by(
+                        func.ts_rank_cd(
+                            func.to_tsvector("sevi", clause_orm_field),
+                            func.plainto_tsquery("sevi", clause.value),
+                        ).desc()
+                    )
+                    q = q.add_columns(
+                        func.ts_rank_cd(
+                            func.to_tsvector("sevi", clause_orm_field),
+                            func.plainto_tsquery("sevi", clause.value),
+                        ).label(f"{clause.field}_score")
+                    )
+                elif clause_prop.db.index_type == IndexType.POSTGRES_TRIGRAM:
+                    # fuzzy search is implemented using Postgres trigram index
+                    # using a custom function f_unaccent to ignore accents -- see `configs/postgres-fts.sql`
+                    q = q.where(
+                        func.f_unaccent(clause_orm_field).bool_op("%>")(
+                            func.f_unaccent(clause.value)
+                        )
+                    )
+                    q = q.order_by(
+                        func.f_unaccent(clause_orm_field).op("<->>")(
+                            func.f_unaccent(clause.value)
+                        )
+                    )
+                    q = q.add_columns(
+                        (
+                            1
+                            - func.f_unaccent(clause_orm_field).op("<->>")(
+                                func.f_unaccent(clause.value)
+                            )
+                        ).label(f"{clause.field}_score")
+                    )
+                else:
+                    raise NotImplementedError(
+                        f"Fuzzy search is not implemented for index type {clause_prop.db.index_type}"
+                    )
 
         for join_condition in query.join_conditions:
             for join_clause in self.join_clauses[join_condition.prop]:
@@ -211,16 +262,29 @@ class BaseAsyncService(Generic[ID, R]):
                     full=join_condition.join_type == "full",
                 ).options(contains_eager(join_clause["contains_eager"]))
 
-                print(">>>", join_clause)
-
-        cq = select(func.count()).select_from(q.subquery())
+        # Create count query without order_by clause to improve performance
+        cq = select(func.count()).select_from(q.order_by(None).subquery())
         rq = q.limit(query.limit).offset(query.offset)
-        records = self._process_result(await session.execute(rq)).scalars().all()
+
+        if len(extra_cols) == 0:
+            records = self._process_result(await session.execute(rq)).scalars().all()
+            extra_columns = {}
+        else:
+            records = []
+            raw_extra_columns = [[] for col in extra_cols]
+            for row in self._process_result(await session.execute(rq)):
+                records.append(row[0])
+                for i in range(len(extra_cols)):
+                    raw_extra_columns[i].append(row[i + 1])
+            extra_columns = {
+                col: raw_extra_columns[i] for i, col in enumerate(extra_cols)
+            }
+
         if query.return_total:
             total = (await session.execute(cq)).scalar_one()
         else:
             total = None
-        return QueryResult(records, total)
+        return QueryResult(records, extra_columns, total)
 
     async def get_by_id(self, id: ID, session: AsyncSession) -> Optional[R]:
         """Retrieving a record by ID."""

{sera_2-1.24.1 → sera_2-1.26.0}/sera/libs/search_helper.py

@@ -253,9 +253,9 @@ class Query(msgspec.Struct):
             else:
                 if join_clause.join_type != "inner":
                     output[target_name].extend(
-                        deser_func((val := getattr(record, source_relprop)))
+                        deser_func(val)
                         for record in result.records
-                        if val is not None
+                        if (val := getattr(record, source_relprop)) is not None
                     )
                 else:
                     output[target_name].extend(
@@ -265,6 +265,8 @@ class Query(msgspec.Struct):
 
         deser_func = dataschema[cls.name].from_db
         output[cls.name] = [deser_func(record) for record in result.records]
+        # include extra columns such as fuzzy search scores
+        output.update(result.extra_columns)
 
         return output
 

{sera_2-1.24.1 → sera_2-1.26.0}/sera/make/make_python_model.py

@@ -22,6 +22,7 @@ from sera.models import (
     Cardinality,
     Class,
     DataProperty,
+    IndexType,
     ObjectProperty,
     Package,
     PyTypeWithDep,
@@ -1207,14 +1208,79 @@ def make_python_relational_model(
         )
 
         index_stmts = []
-        if len(cls.db.indices) > 0:
+
+        if len(cls.db.indices) > 0 or any(
+            isinstance(prop, DataProperty)
+            and prop.db is not None
+            and prop.db.is_indexed
+            and (
+                prop.db.index_type == IndexType.POSTGRES_FTS_SEVI
+                or prop.db.index_type == IndexType.POSTGRES_TRIGRAM
+            )
+            for prop in cls.properties.values()
+        ):
             program.import_("sqlalchemy.Index", True)
+
+            fts_index = []
+            for prop in cls.properties.values():
+                if (
+                    not isinstance(prop, DataProperty)
+                    or prop.db is None
+                    or not prop.db.is_indexed
+                ):
+                    continue
+                if prop.db.index_type == IndexType.POSTGRES_FTS_SEVI:
+                    fts_index.append(
+                        expr.ExprFuncCall(
+                            expr.ExprIdent("Index"),
+                            [
+                                expr.ExprConstant(
+                                    f"ix_{cls.db.table_name}_{get_property_name(prop)}_gin"
+                                ),
+                                expr.ExprFuncCall(
+                                    ident_manager.use("text"),
+                                    [
+                                        expr.ExprConstant(
+                                            f"to_tsvector('sevi', {get_property_name(prop)})"
+                                        )
+                                    ],
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "postgresql_using", expr.ExprConstant("gin")
+                                ),
+                            ],
+                        )
+                    )
+                if prop.db.index_type == IndexType.POSTGRES_TRIGRAM:
+                    fts_index.append(
+                        expr.ExprFuncCall(
+                            expr.ExprIdent("Index"),
+                            [
+                                expr.ExprConstant(
+                                    f"ix_{cls.db.table_name}_{get_property_name(prop)}_gist"
+                                ),
+                                expr.ExprFuncCall(
+                                    expr.ExprIdent("text"),
+                                    [
+                                        expr.ExprConstant(
+                                            f"f_unaccent({get_property_name(prop)}) gist_trgm_ops(siglen=256)"
+                                        )
+                                    ],
+                                ),
+                                PredefinedFn.keyword_assignment(
+                                    "postgresql_using", expr.ExprConstant("gist")
+                                ),
+                            ],
+                        )
+                    )
+
             index_stmts.append(
                 stmt.DefClassVarStatement(
                     "_table_args__",
                     None,
                     PredefinedFn.tuple(
-                        [
+                        fts_index
+                        + [
                             expr.ExprFuncCall(
                                 expr.ExprIdent("Index"),
                                 [expr.ExprConstant(index.name)]
@@ -1317,7 +1383,8 @@ def make_python_relational_model(
                                 "unique", expr.ExprConstant(True)
                             )
                         )
-                    elif prop.db.is_indexed:
+                    elif prop.db.is_indexed and prop.db.index_type == IndexType.DEFAULT:
+                        # only add index=True for default index type
                         propvalargs.append(
                             PredefinedFn.keyword_assignment(
                                 "index", expr.ExprConstant(True)

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

@@ -8,6 +8,7 @@ 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.make_query import make_query
 from sera.make.ts_frontend.misc import TS_GLOBAL_IDENTS, get_normalizer
 from sera.misc import (
     assert_isinstance,
@@ -1144,50 +1145,6 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
 
         outmod.write(program)
 
-    def make_query_processor(cls: Class, pkg: Package):
-        if not cls.is_public:
-            # skip classes that are not public
-            return
-
-        outmod = pkg.module(cls.name + "Query")
-
-        program = Program()
-        program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}", True)
-        program.import_(f"sera-db.QueryProcessor", True)
-
-        query_args = []
-        for prop in cls.properties.values():
-            pypropname = prop.name
-            tspropname = to_camel_case(prop.name)
-
-            if isinstance(prop, ObjectProperty) and prop.target.db is not None:
-                tspropname = tspropname + "Id"
-                pypropname = prop.name + "_id"
-
-            if tspropname != pypropname:
-                query_args.append(
-                    (
-                        expr.ExprIdent(tspropname),
-                        expr.ExprConstant(pypropname),
-                    )
-                )
-
-        program.root(
-            stmt.LineBreak(),
-            stmt.TypescriptStatement(
-                f"export const query = "
-                + expr.ExprNewInstance(
-                    expr.ExprIdent(f"QueryProcessor<{cls.name}>"),
-                    [
-                        PredefinedFn.dict(query_args),
-                    ],
-                ).to_typescript()
-                + ";",
-            ),
-        )
-
-        outmod.write(program)
-
     def make_index(pkg: Package):
         outmod = pkg.module("index")
         if outmod.exists():
@@ -1209,7 +1166,11 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         program.import_(
             f"@.models.{pkg.dir.name}.{cls.name}Schema.{cls.name}Schema", True
         )
+        program.import_(
+            f"@.models.{pkg.dir.name}.{cls.name}Query.{cls.name}Query", True
+        )
         export_types.append(f"{cls.name}Schema")
+        export_iso_types.append(f"{cls.name}Query")
         program.import_(
             f"@.models.{pkg.dir.name}.{cls.name}Schema.{cls.name}SchemaType", True
         )
@@ -1241,7 +1202,7 @@ def make_typescript_data_model(schema: Schema, target_pkg: Package):
         pkg = target_pkg.pkg(cls.get_tsmodule_name())
         make_normal(cls, pkg)
         make_draft(cls, pkg)
-        make_query_processor(cls, pkg)
+        make_query(schema, cls, pkg)
         make_table(cls, pkg)
         make_class_schema(schema, cls, pkg)
 

{sera_2-1.24.1 → sera_2-1.26.0}/sera/make/ts_frontend/make_enums.py

@@ -1,32 +1,13 @@
 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 codegen.models import PredefinedFn, Program, expr, stmt
 
-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):

sera_2-1.26.0/sera/make/ts_frontend/make_query.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
+from codegen.models.var import DeferredVar
+from loguru import logger
+
+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,
+)
+
+
+def make_query(schema: Schema, cls: Class, pkg: Package):
+    """Make query processor and query schema.
+
+    Args:
+        schema: The overall schema of the application, which contains all classes & enums
+        cls: The class that we want to generate the query processor and 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 query helper directly to a file.
+    """
+    if not cls.is_public:
+        # skip classes that are not public
+        return
+
+    outmod = pkg.module(cls.name + "Query")
+
+    program = Program()
+    program.import_(f"@.models.{pkg.dir.name}.{cls.name}.{cls.name}", True)
+    program.import_(f"sera-db.QueryProcessor", True)
+    program.import_(f"sera-db.Query", True)
+
+    query_args = []
+    for prop in cls.properties.values():
+        pypropname = prop.name
+        tspropname = to_camel_case(prop.name)
+
+        if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+            tspropname = tspropname + "Id"
+            pypropname = prop.name + "_id"
+
+        if tspropname != pypropname:
+            query_args.append(
+                (
+                    expr.ExprIdent(tspropname),
+                    expr.ExprConstant(pypropname),
+                )
+            )
+
+    query_condition_args = []
+    for prop in cls.properties.values():
+        if prop.db is None or prop.data.is_private:
+            # This property is not stored in the database or it's private, so we skip it
+            continue
+        if (
+            isinstance(prop, DataProperty)
+            and prop.db is not None
+            and not prop.db.is_indexed
+        ):
+            # This property is not indexed, so we skip it
+            continue
+        if isinstance(prop, ObjectProperty) and prop.target.db is None:
+            # TODO: Implement this! This property is an embedded object property, we need to figure out
+            # which necessary properties are queryable and add them to the field names
+            continue
+
+        tspropname = to_camel_case(prop.name)
+        if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+            # This property is an object property stored in the database, "Id" is added to the property name
+            tspropname = tspropname + "Id"
+
+        if isinstance(prop, DataProperty):
+            tstype = prop.datatype.get_typescript_type()
+        else:
+            assert isinstance(prop, ObjectProperty)
+            tstype = assert_not_null(
+                prop.target.get_id_property()
+            ).datatype.get_typescript_type()
+
+        for dep in tstype.deps:
+            program.import_(dep, is_import_attr=True)
+
+        if tstype.type == "string":
+            op = '"fuzzy"'
+        elif tstype.type in "number" or tstype.type == "Date":
+            op = '"eq" | "ne" | "lt" | "lte" | "gt" | "gte"'
+        elif tstype.is_enum_type():
+            op = '"eq" | "ne"'
+        else:
+            raise NotImplementedError(tstype.type)
+
+        if tstype.type == "Date":
+            # for date type, we use timestamp (number) for comparison
+            value = "number"
+        else:
+            value = tstype.type
+
+        query_condition_args.append(
+            (
+                expr.ExprIdent(tspropname + "?"),
+                PredefinedFn.dict(
+                    [
+                        (expr.ExprIdent("op"), expr.ExprIdent(op)),
+                        (expr.ExprIdent("value"), expr.ExprIdent(value)),
+                    ]
+                ),
+            )
+        )
+
+    program.root(
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"export const query = "
+            + expr.ExprNewInstance(
+                expr.ExprIdent(f"QueryProcessor<{cls.name}>"),
+                [
+                    PredefinedFn.dict(query_args),
+                ],
+            ).to_typescript()
+            + ";",
+        ),
+        stmt.LineBreak(),
+        stmt.TypescriptStatement(
+            f"export type {cls.name}Query = Query<{cls.name}, "
+            + PredefinedFn.dict(query_condition_args).to_typescript()
+            + ">;"
+        ),
+    )
+
+    outmod.write(program)

{sera_2-1.24.1 → sera_2-1.26.0}/sera/make/ts_frontend/misc.py

@@ -2,17 +2,9 @@ from __future__ import annotations
 
 from typing import Optional
 
-from codegen.models import AST, ImportHelper, PredefinedFn, Program, expr, stmt
+from codegen.models import ImportHelper, expr
 
-from sera.models import (
-    Class,
-    DataProperty,
-    Enum,
-    ObjectProperty,
-    Package,
-    Schema,
-    TsTypeWithDep,
-)
+from sera.models import TsTypeWithDep
 
 TS_GLOBAL_IDENTS = {
     "normalizers.normalizeNumber": "sera-db.normalizers",

{sera_2-1.24.1 → sera_2-1.26.0}/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_2-1.24.1 → sera_2-1.26.0}/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_2-1.24.1 → sera_2-1.26.0}/sera/models/_collection.py

@@ -55,7 +55,11 @@ class DataCollection:
         """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:
+            if (
+                isinstance(prop, DataProperty)
+                and prop.db is not None
+                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

{sera_2-1.24.1 → sera_2-1.26.0}/sera/models/_module.py

@@ -183,4 +183,3 @@ class App:
     def name(self) -> str:
         """Get the name of the application"""
         return self.root.dir.name
-        return self.root.dir.name

{sera_2-1.24.1 → sera_2-1.26.0}/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,
@@ -150,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", "")),
@@ -164,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
@@ -173,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_2-1.24.1 → sera_2-1.26.0}/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_2-1.24.1 → sera_2-1.26.0}/sera/typing.py

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