sera-2 1.25.0__tar.gz → 1.26.1__tar.gz

{sera_2-1.25.0 → sera_2-1.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sera-2
-Version: 1.25.0
+Version: 1.26.1
 Summary: 
 Author: Binh Vu
 Author-email: bvu687@gmail.com

{sera_2-1.25.0 → sera_2-1.26.1}/pyproject.toml

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

{sera_2-1.25.0 → sera_2-1.26.1}/sera/make/make_python_model.py

@@ -12,6 +12,7 @@ from codegen.models import (
     stmt,
 )
 
+from sera.make.py_backend.misc import get_python_property_name
 from sera.misc import (
     assert_isinstance,
     assert_not_null,
@@ -110,21 +111,21 @@ def make_python_data_model(
             ), "If value_pass_as_args is provided, record should not be used as a dummy value should be passed instead."
         else:
             value = PredefinedFn.attr_getter(record, expr.ExprIdent(prop.name))
+
+        propname = get_python_property_name(prop)
         if isinstance(prop, ObjectProperty) and prop.target.db is not None:
             if prop.cardinality.is_star_to_many():
                 value = PredefinedFn.map_list(
                     value,
                     lambda item: PredefinedFn.attr_getter(
-                        item, expr.ExprIdent(prop.name + "_id")
+                        item, expr.ExprIdent(propname)
                     ),
                 )
             else:
                 assert (
                     value_pass_as_args is None
                 ), "Cannot use value_pass_as_args for a single object property."
-                value = PredefinedFn.attr_getter(
-                    record, expr.ExprIdent(prop.name + "_id")
-                )
+                value = PredefinedFn.attr_getter(record, expr.ExprIdent(propname))
 
             target_idprop = assert_not_null(prop.target.get_id_property())
             conversion_fn = get_data_conversion(
@@ -147,10 +148,8 @@ def make_python_data_model(
         mode: Literal["create", "update"],
         prop: DataProperty | ObjectProperty,
     ):
-        if isinstance(prop, ObjectProperty) and prop.target.db is not None:
-            propname = prop.name + "_id"
-        else:
-            propname = prop.name
+        propname = get_python_property_name(prop)
+
         value = PredefinedFn.attr_getter(slf, expr.ExprIdent(propname))
         if isinstance(prop, ObjectProperty):
             if (
@@ -178,7 +177,7 @@ def make_python_data_model(
                         expr.ExprIdent(AssociationTable),
                         [
                             PredefinedFn.keyword_assignment(
-                                f"{prop.name}_id", conversion_fn(item)
+                                propname, conversion_fn(item)
                             )
                         ],
                     ),
@@ -236,6 +235,8 @@ def make_python_data_model(
             if prop.data.system_controlled is None:
                 continue
 
+            propname = get_python_property_name(prop)
+
             update_func = None
             if mode == "create":
                 if prop.data.system_controlled.on_create_bypass is not None:
@@ -294,7 +295,7 @@ def make_python_data_model(
 
             smt = stmt.AssignStatement(
                 PredefinedFn.attr_getter(
-                    expr.ExprIdent("self"), expr.ExprIdent(prop.name)
+                    expr.ExprIdent("self"), expr.ExprIdent(propname)
                 ),
                 epr,
             )
@@ -374,6 +375,7 @@ def make_python_data_model(
             ):
                 continue
 
+            propname = get_python_property_name(prop)
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type().clone()
                 if len(prop.data.constraints) > 0:
@@ -419,21 +421,17 @@ def make_python_data_model(
                     )
 
                 cls_ast(
-                    stmt.DefClassVarStatement(
-                        prop.name, pytype.type, prop_default_value
-                    )
+                    stmt.DefClassVarStatement(propname, pytype.type, prop_default_value)
                 )
             elif isinstance(prop, ObjectProperty):
                 if prop.target.db is not None:
                     # if the target class is in the database, we expect the user to pass the foreign key for it.
-                    propname = prop.name + "_id"
                     pytype = (
                         assert_not_null(prop.target.get_id_property())
                         .get_data_model_datatype()
                         .get_python_type()
                     )
                 else:
-                    propname = prop.name
                     pytype = PyTypeWithDep(
                         f"Create{prop.target.name}",
                         [
@@ -561,6 +559,8 @@ def make_python_data_model(
             ):
                 continue
 
+            propname = get_python_property_name(prop)
+
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type().clone()
 
@@ -605,13 +605,10 @@ def make_python_data_model(
                     )
 
                 cls_ast(
-                    stmt.DefClassVarStatement(
-                        prop.name, pytype.type, prop_default_value
-                    )
+                    stmt.DefClassVarStatement(propname, pytype.type, prop_default_value)
                 )
             elif isinstance(prop, ObjectProperty):
                 if prop.target.db is not None:
-                    propname = prop.name + "_id"
                     # if the target class is in the database, we expect the user to pass the foreign key for it.
                     pytype = (
                         assert_not_null(prop.target.get_id_property())
@@ -620,7 +617,6 @@ def make_python_data_model(
                     )
 
                 else:
-                    propname = prop.name
                     pytype = PyTypeWithDep(
                         f"Update{prop.target.name}",
                         [
@@ -686,7 +682,9 @@ def make_python_data_model(
                                     [
                                         PredefinedFn.attr_getter(
                                             expr.ExprIdent("self"),
-                                            expr.ExprIdent(prop.name),
+                                            expr.ExprIdent(
+                                                get_python_property_name(prop)
+                                            ),
                                         )
                                     ],
                                 )
@@ -750,7 +748,7 @@ def make_python_data_model(
                 # skip private fields as this is for APIs exchange
                 continue
 
-            propname = prop.name
+            propname = get_python_property_name(prop)
             if isinstance(prop, DataProperty):
                 pytype = prop.get_data_model_datatype().get_python_type()
                 if prop.is_optional:
@@ -759,10 +757,9 @@ def make_python_data_model(
                 for dep in pytype.deps:
                     program.import_(dep, True)
 
-                cls_ast(stmt.DefClassVarStatement(prop.name, pytype.type))
+                cls_ast(stmt.DefClassVarStatement(propname, pytype.type))
             elif isinstance(prop, ObjectProperty):
                 if prop.target.db is not None:
-                    propname = prop.name + "_id"
                     pytype = (
                         assert_not_null(prop.target.get_id_property())
                         .get_data_model_datatype()
@@ -823,12 +820,14 @@ def make_python_data_model(
             as_composite_args = [DeferredVar.simple("cls")]
             as_composite_null_condition = []
             for prop in cls.properties.values():
+                propname = get_python_property_name(prop)
+
                 assert (
                     not prop.data.is_private
-                ), f"Embedded classes should not have private properties: {cls.name}.{prop.name}"
-                as_composite_args.append(DeferredVar.simple(prop.name))
+                ), f"Embedded classes should not have private properties: {cls.name}.{propname}"
+                as_composite_args.append(DeferredVar.simple(propname))
                 as_composite_null_condition.append(
-                    expr.ExprIs(expr.ExprIdent(prop.name), expr.ExprConstant(None))
+                    expr.ExprIs(expr.ExprIdent(propname), expr.ExprConstant(None))
                 )
 
             # For simplicity, we assume that this embedded class can be used in a nullable field (check if all properties are None and return None).
@@ -855,7 +854,9 @@ def make_python_data_model(
                             expr.ExprIdent("cls"),
                             [
                                 from_db_type_conversion(
-                                    expr.ExprIdent(""), prop, expr.ExprIdent(prop.name)
+                                    expr.ExprIdent(""),
+                                    prop,
+                                    expr.ExprIdent(get_python_property_name(prop)),
                                 )
                                 for prop in cls.properties.values()
                             ],
@@ -946,12 +947,6 @@ def make_python_relational_model(
     """
     app = target_pkg.app
 
-    def get_property_name(prop: DataProperty | ObjectProperty):
-        if isinstance(prop, ObjectProperty):
-            if prop.target.db is not None:
-                return f"{prop.name}_id"
-        return prop.name
-
     def make_base(custom_types: Sequence[ObjectProperty]):
         """Make a base class for our database."""
         program = Program()
@@ -1229,19 +1224,20 @@ def make_python_relational_model(
                     or not prop.db.is_indexed
                 ):
                     continue
+                propname = get_python_property_name(prop)
                 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"
+                                    f"ix_{cls.db.table_name}_{propname}_gin"
                                 ),
                                 expr.ExprFuncCall(
                                     ident_manager.use("text"),
                                     [
                                         expr.ExprConstant(
-                                            f"to_tsvector('sevi', {get_property_name(prop)})"
+                                            f"to_tsvector('sevi', {propname})"
                                         )
                                     ],
                                 ),
@@ -1257,13 +1253,13 @@ def make_python_relational_model(
                             expr.ExprIdent("Index"),
                             [
                                 expr.ExprConstant(
-                                    f"ix_{cls.db.table_name}_{get_property_name(prop)}_gist"
+                                    f"ix_{cls.db.table_name}_{propname}_gist"
                                 ),
                                 expr.ExprFuncCall(
                                     expr.ExprIdent("text"),
                                     [
                                         expr.ExprConstant(
-                                            f"f_unaccent({get_property_name(prop)}) gist_trgm_ops(siglen=256)"
+                                            f"f_unaccent({propname}) gist_trgm_ops(siglen=256)"
                                         )
                                     ],
                                 ),
@@ -1286,7 +1282,7 @@ def make_python_relational_model(
                                 [expr.ExprConstant(index.name)]
                                 + [
                                     expr.ExprConstant(
-                                        get_property_name(cls.properties[prop])
+                                        get_python_property_name(cls.properties[prop])
                                     )
                                     for prop in index.columns
                                 ]
@@ -1496,7 +1492,7 @@ def make_python_relational_object_property(
             )
 
         # we store this class in the database
-        propname = f"{prop.name}_id"
+        propname = get_python_property_name(prop)
         idprop = prop.target.get_id_property()
         assert idprop is not None
         idprop_pytype = idprop.datatype.get_sqlalchemy_type()

{sera_2-1.25.0 → sera_2-1.26.1}/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.26.1/sera/make/py_backend/misc.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from sera.models import DataProperty, ObjectProperty
+
+
+def get_python_property_name(prop: DataProperty | ObjectProperty) -> str:
+    """Get property name of a property in Python model"""
+    if isinstance(prop, ObjectProperty) and prop.target.db is not None:
+        # the property value is a foreign key to another table, we should add _id to
+        # the end of the property name
+        return prop.name + "_id"
+    else:
+        return prop.name

{sera_2-1.25.0 → sera_2-1.26.1}/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.1/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.25.0 → sera_2-1.26.1}/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.25.0 → sera_2-1.26.1}/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.25.0 → sera_2-1.26.1}/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