sera-2 1.12.3__py3-none-any.whl → 1.13.0__py3-none-any.whl

sera/exports/schema.py

@@ -0,0 +1,157 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from sera.models import Cardinality, Class, DataProperty, Schema, parse_schema
+from sera.models._datatype import DataType
+
+
+def get_prisma_field_type(datatype: DataType) -> str:
+    pytype = datatype.get_python_type().type
+    if pytype == "str":
+        return "String"
+    if pytype == "int":
+        return "Int"
+    if pytype == "float":
+        return "Float"
+    if pytype == "bool":
+        return "Boolean"
+    if pytype == "bytes":
+        return "Bytes"
+    if pytype == "dict":
+        return "Json"
+    if pytype == "datetime":
+        return "DateTime"
+    if pytype == "list[str]":
+        return "String[]"
+    if pytype == "list[int]":
+        return "Int[]"
+    if pytype == "list[float]":
+        return "Float[]"
+    if pytype == "list[bool]":
+        return "Boolean[]"
+    if pytype == "list[bytes]":
+        return "Bytes[]"
+    if pytype == "list[dict]":
+        return "Json[]"
+    if pytype == "list[datetime]":
+        return "DateTime[]"
+
+    raise ValueError(f"Unsupported data type for Prisma: {pytype}")
+
+
+def to_prisma_model(schema: Schema, cls: Class, lines: list[str]):
+    """Convert a Sera Class to a Prisma model string representation."""
+    lines.append(f"model {cls.name} {{")
+
+    if cls.db is None:
+        # This class has no database mapping, we must generate a default key for it
+        lines.append(
+            f"  {'id'.ljust(30)} {'Int'.ljust(10)} @id @default(autoincrement())"
+        )
+    #     lines.append(f"  @@unique([%s])" % ", ".join(cls.properties.keys()))
+
+    for prop in cls.properties.values():
+        propattrs = ""
+        if isinstance(prop, DataProperty):
+            proptype = get_prisma_field_type(prop.datatype)
+            if prop.is_optional:
+                proptype = f"{proptype}?"
+            if prop.db is not None and prop.db.is_primary_key:
+                propattrs += "@id "
+
+            lines.append(f"  {prop.name.ljust(30)} {proptype.ljust(10)} {propattrs}")
+            continue
+
+        if prop.cardinality == Cardinality.MANY_TO_MANY:
+            # For many-to-many relationships, we need to handle the join table
+            lines.append(
+                f"  {prop.name.ljust(30)} {(prop.target.name + '[]').ljust(10)}"
+            )
+        else:
+            lines.append(
+                f"  {(prop.name + '_').ljust(30)} {prop.target.name.ljust(10)} @relation(fields: [{prop.name}], references: [id])"
+            )
+            lines.append(f"  {prop.name.ljust(30)} {'Int'.ljust(10)} @unique")
+
+    lines.append("")
+    for upstream_cls, reverse_upstream_prop in schema.get_upstream_classes(cls):
+        if (
+            reverse_upstream_prop.cardinality == Cardinality.MANY_TO_ONE
+            or reverse_upstream_prop.cardinality == Cardinality.MANY_TO_MANY
+        ):
+
+            proptype = f"{upstream_cls.name}[]"
+        else:
+            proptype = upstream_cls.name + "?"
+        lines.append(f"  {upstream_cls.name.lower().ljust(30)} {proptype.ljust(10)}")
+
+    lines.append("}\n")
+
+
+def export_prisma_schema(schema: Schema, outfile: Path):
+    """Export Prisma schema file"""
+    lines = []
+
+    # Datasource
+    lines.append("datasource db {")
+    lines.append(
+        '  provider = "postgresql"'
+    )  # Defaulting to postgresql as per user context
+    lines.append('  url      = env("DATABASE_URL")')
+    lines.append("}\n")
+
+    # Generator
+    lines.append("generator client {")
+    lines.append('  provider = "prisma-client-py"')
+    lines.append("  recursive_type_depth = 5")
+    lines.append("}\n")
+
+    # Enums
+    if schema.enums:
+        for enum_name, enum_def in schema.enums.items():
+            lines.append(f"enum {enum_name} {{")
+            # Assuming enum_def.values is a list of strings based on previous errors
+            for val_str in enum_def.values:
+                lines.append(f"  {val_str}")
+            lines.append("}\\n")
+
+    # Models
+    for cls in schema.topological_sort():
+        to_prisma_model(schema, cls, lines)
+
+    with outfile.open("w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+
+app = typer.Typer(pretty_exceptions_short=True, pretty_exceptions_enable=False)
+
+
+@app.command()
+def cli(
+    schema_files: Annotated[
+        list[Path],
+        typer.Option(
+            "-s", help="YAML schema files. Multiple files are merged automatically"
+        ),
+    ],
+    outfile: Annotated[
+        Path,
+        typer.Option(
+            "-o", "--output", help="Output file for the Prisma schema", writable=True
+        ),
+    ],
+):
+    schema = parse_schema(
+        "sera",
+        schema_files,
+    )
+    export_prisma_schema(
+        schema,
+        outfile,
+    )
+
+
+if __name__ == "__main__":
+    app()

sera/exports/test.py

@@ -0,0 +1,70 @@
+from sqlalchemy import (
+    Column,
+    ForeignKey,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    create_engine,
+)
+from sqlalchemy.schema import CreateTable
+
+# Define your SQLAlchemy engine (dialect matters for SQL output)
+# Using a specific dialect helps generate appropriate SQL
+# engine = create_engine(
+#     "postgresql+psycopg2://user:password@host:port/database", echo=False
+# )
+# Or for SQLite:
+# engine = create_engine("sqlite:///:memory:")
+# Or for MySQL:
+# engine = create_engine("mysql+mysqlconnector://user:password@host:port/database")
+
+
+metadata_obj = MetaData()
+
+user_table = Table(
+    "users",
+    metadata_obj,
+    Column("id", Integer, primary_key=True),
+    Column("name", String(50)),
+    Column("email", String(100), unique=True),
+)
+
+address_table = Table(
+    "addresses",
+    metadata_obj,
+    Column("id", Integer, primary_key=True),
+    Column("user_id", Integer, ForeignKey("users.id"), nullable=False),
+    Column("street_name", String(100)),
+    Column("city", String(50)),
+)
+
+# --- ORM Example ---
+# from sqlalchemy.orm import declarative_base, Mapped, mapped_column
+# Base = declarative_base()
+# metadata_obj = Base.metadata
+# class User(Base): # ... (define as above)
+# class Address(Base): # ... (define as above)
+# -------------------
+
+print("--- Generating DDL for PostgreSQL ---")
+
+
+def generate_schema_ddl(metadata, engine_dialect):
+    for table in metadata.sorted_tables:
+        # The CreateTable construct can be compiled to a string
+        # specific to the dialect of the engine.
+        create_table_ddl = CreateTable(table).compile(dialect=engine_dialect)
+        print(str(create_table_ddl).strip() + ";\n")
+
+
+from sqlalchemy.dialects import postgresql, sqlite
+
+generate_schema_ddl(metadata_obj, postgresql.dialect())
+
+# # Example with a different dialect (e.g., SQLite)
+# # Note: You don't need a live connection for this, just the dialect.
+
+
+# print("\n--- Generating DDL for SQLite ---")
+# generate_schema_ddl(metadata_obj, sqlite.dialect())

sera/libs/base_orm.py

@@ -4,10 +4,12 @@ from typing import Optional
 
 import orjson
 from msgspec.json import decode, encode
-from sera.typing import UNSET
 from sqlalchemy import LargeBinary, TypeDecorator
 from sqlalchemy import create_engine as sqlalchemy_create_engine
 from sqlalchemy import update
+from sqlalchemy.ext.asyncio import create_async_engine as sqlalchemy_create_async_engine
+
+from sera.typing import UNSET
 
 
 class BaseORM:
@@ -104,11 +106,27 @@ class DictDataclassType(TypeDecorator):
 def create_engine(
     dbconn: str,
     connect_args: Optional[dict] = None,
-    debug: bool = False,
+    echo: bool = False,
+):
+    if dbconn.startswith("sqlite"):
+        connect_args = {"check_same_thread": False}
+    else:
+        connect_args = {}
+    engine = sqlalchemy_create_engine(dbconn, connect_args=connect_args, echo=echo)
+    return engine
+
+
+def create_async_engine(
+    dbconn: str,
+    connect_args: Optional[dict] = None,
+    echo: bool = False,
 ):
     if dbconn.startswith("sqlite"):
         connect_args = {"check_same_thread": False}
     else:
         connect_args = {}
-    engine = sqlalchemy_create_engine(dbconn, connect_args=connect_args, echo=debug)
+
+    engine = sqlalchemy_create_async_engine(
+        dbconn, connect_args=connect_args, echo=echo
+    )
     return engine

sera/libs/base_service.py

@@ -4,8 +4,11 @@ from enum import Enum
 from math import dist
 from typing import Annotated, Any, Generic, NamedTuple, Optional, Sequence, TypeVar
 
-from sqlalchemy import Result, Select, exists, func, select
-from sqlalchemy.orm import Session, load_only
+from litestar.exceptions import HTTPException
+from sqlalchemy import Result, Select, delete, exists, func, select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import load_only
 
 from sera.libs.base_orm import BaseORM
 from sera.misc import assert_not_null
@@ -41,7 +44,7 @@ class QueryResult(NamedTuple, Generic[R]):
     total: int
 
 
-class BaseService(Generic[ID, R]):
+class BaseAsyncService(Generic[ID, R]):
 
     instance = None
 
@@ -51,7 +54,7 @@ class BaseService(Generic[ID, R]):
         self.id_prop = assert_not_null(cls.get_id_property())
 
         self._cls_id_prop = getattr(self.orm_cls, self.id_prop.name)
-        self.is_id_auto_increment = self.id_prop.db.is_auto_increment
+        self.is_id_auto_increment = assert_not_null(self.id_prop.db).is_auto_increment
 
     @classmethod
     def get_instance(cls):
@@ -59,10 +62,10 @@ class BaseService(Generic[ID, R]):
         if cls.instance is None:
             # assume that the subclass overrides the __init__ method
             # so that we don't need to pass the class and orm_cls
-            cls.instance = cls()
+            cls.instance = cls()  # type: ignore[call-arg]
         return cls.instance
 
-    def get(
+    async def get(
         self,
         query: Query,
         limit: int,
@@ -71,7 +74,7 @@ class BaseService(Generic[ID, R]):
         sorted_by: list[str],
         group_by: list[str],
         fields: list[str],
-        session: Session,
+        session: AsyncSession,
     ) -> QueryResult[R]:
         """Retrieving records matched a query.
 
@@ -103,35 +106,37 @@ class BaseService(Generic[ID, R]):
 
         cq = select(func.count()).select_from(q.subquery())
         rq = q.limit(limit).offset(offset)
-        records = self._process_result(session.execute(rq)).scalars().all()
-        total = session.execute(cq).scalar_one()
+        records = self._process_result(await session.execute(rq)).scalars().all()
+        total = (await session.execute(cq)).scalar_one()
         return QueryResult(records, total)
 
-    def get_by_id(self, id: ID, session: Session) -> Optional[R]:
+    async def get_by_id(self, id: ID, session: AsyncSession) -> Optional[R]:
         """Retrieving a record by ID."""
         q = self._select().where(self._cls_id_prop == id)
-        result = self._process_result(session.execute(q)).scalar_one_or_none()
+        result = self._process_result(await session.execute(q)).scalar_one_or_none()
         return result
 
-    def has_id(self, id: ID, session: Session) -> bool:
+    async def has_id(self, id: ID, session: AsyncSession) -> bool:
         """Check whether we have a record with the given ID."""
-        q = exists().where(self._cls_id_prop == id)
-        result = session.query(q).scalar()
+        q = exists().where(self._cls_id_prop == id).select()
+        result = (await session.execute(q)).scalar()
         return bool(result)
 
-    def create(self, record: R, session: Session) -> R:
+    async def create(self, record: R, session: AsyncSession) -> R:
         """Create a new record."""
         if self.is_id_auto_increment:
             setattr(record, self.id_prop.name, None)
 
-        session.add(record)
-        session.commit()
+        try:
+            session.add(record)
+            await session.flush()
+        except IntegrityError:
+            raise HTTPException(detail="Invalid request", status_code=409)
         return record
 
-    def update(self, record: R, session: Session) -> R:
+    async def update(self, record: R, session: AsyncSession) -> R:
         """Update an existing record."""
-        session.execute(record.get_update_query())
-        session.commit()
+        await session.execute(record.get_update_query())
         return record
 
     def _select(self) -> Select:
@@ -141,3 +146,7 @@ class BaseService(Generic[ID, R]):
     def _process_result(self, result: SqlResult) -> SqlResult:
         """Process the result of a query."""
         return result
+
+    async def truncate(self, session: AsyncSession) -> None:
+        """Truncate the table."""
+        await session.execute(delete(self.orm_cls))

sera/libs/middlewares/auth.py

@@ -1,16 +1,13 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
-from typing import Callable, Generator, Generic, Optional, Sequence, Type
+from typing import Awaitable, Callable, Generic, Sequence
 
 from litestar import Request
 from litestar.connection import ASGIConnection
 from litestar.exceptions import NotAuthorizedException
 from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult
 from litestar.types import ASGIApp, Method, Scopes
-from litestar.types.composite_types import Dependencies
-from sqlalchemy import select
-from sqlalchemy.orm import Session
 
 from sera.typing import T
 
@@ -26,7 +23,7 @@ class AuthMiddleware(AbstractAuthenticationMiddleware, Generic[T]):
     def __init__(
         self,
         app: ASGIApp,
-        user_handler: Callable[[str], T],
+        user_handler: Callable[[str], Awaitable[T]],
         exclude: str | list[str] | None = None,
         exclude_from_auth_key: str = "exclude_from_auth",
         exclude_http_methods: Sequence[Method] | None = None,
@@ -59,7 +56,7 @@ class AuthMiddleware(AbstractAuthenticationMiddleware, Generic[T]):
                 detail="Credentials expired",
             )
 
-        user = self.user_handler(userid)
+        user = await self.user_handler(userid)
         if user is None:
             raise NotAuthorizedException(
                 detail="User not found",

sera/make/__main__.py

@@ -49,4 +49,5 @@ def cli(
     make_app(app_dir, schema_files, api_collections, language, referenced_schema)
 
 
-app()
+if __name__ == "__main__":
+    app()