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

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

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

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

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

{sera_2-1.25.0 → 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.25.0 → 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.25.0 → 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.25.0 → 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.25.0 → 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