python-flashapi 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

flashapi/storage/base.py

@@ -1,26 +1,32 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class Storage(ABC):
-    @abstractmethod
-    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
-        ...
-
-    @abstractmethod
-    def get(self, table: str, item_id: int | str) -> dict[str, Any] | None:
-        ...
-
-    @abstractmethod
-    def list_all(self, table: str) -> list[dict[str, Any]]:
-        ...
-
-    @abstractmethod
-    def update(self, table: str, item_id: int | str, data: dict[str, Any]) -> dict[str, Any] | None:
-        ...
-
-    @abstractmethod
-    def delete(self, table: str, item_id: int | str) -> bool:
-        ...
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Storage(ABC):
+    @abstractmethod
+    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
+        ...
+
+    @abstractmethod
+    def get(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> dict[str, Any] | None:
+        ...
+
+    @abstractmethod
+    def list_all(self, table: str, *, include_deleted: bool = False, only_deleted: bool = False) -> list[dict[str, Any]]:
+        ...
+
+    @abstractmethod
+    def update(self, table: str, item_id: int | str, data: dict[str, Any], *, lookup_field: str = "id") -> dict[str, Any] | None:
+        ...
+
+    @abstractmethod
+    def delete(self, table: str, item_id: int | str, *, soft: bool = True, lookup_field: str = "id") -> bool:
+        ...
+
+    def restore(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> bool:
+        return False
+
+    def bulk_create(self, table: str, items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        return [self.create(table, item) for item in items]

flashapi/storage/orm.py

@@ -1,85 +1,125 @@
-from __future__ import annotations
-
-from typing import Any
-
-from flashapi.storage.base import Storage
-
-
-class DjangoORMStorage(Storage):
-    """Storage backend that delegates to Django's ORM."""
-
-    def __init__(self, model_class: type):
-        self._model = model_class
-
-    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
-        instance = self._model.objects.create(**data)
-        return self._to_dict(instance)
-
-    def get(self, table: str, item_id: int | str) -> dict[str, Any] | None:
-        try:
-            instance = self._model.objects.get(pk=item_id)
-            return self._to_dict(instance)
-        except self._model.DoesNotExist:
-            return None
-
-    def list_all(self, table: str) -> list[dict[str, Any]]:
-        return [self._to_dict(obj) for obj in self._model.objects.all()]
-
-    def update(self, table: str, item_id: int | str, data: dict[str, Any]) -> dict[str, Any] | None:
-        try:
-            instance = self._model.objects.get(pk=item_id)
-        except self._model.DoesNotExist:
-            return None
-
-        for key, value in data.items():
-            setattr(instance, key, value)
-        instance.save()
-        return self._to_dict(instance)
-
-    def delete(self, table: str, item_id: int | str) -> bool:
-        try:
-            instance = self._model.objects.get(pk=item_id)
-            instance.delete()
-            return True
-        except self._model.DoesNotExist:
-            return False
-
-    def _to_dict(self, instance) -> dict[str, Any]:
-
-        data = {}
-        for field in instance._meta.get_fields():
-            if field.many_to_many or field.one_to_many:
-                continue
-            if hasattr(field, "related_model") and field.related_model:
-                name = field.attname
-            else:
-                name = field.name
-            value = getattr(instance, name, None)
-            data[name] = self._serialize_value(value)
-        return data
-
-    def _serialize_value(self, value) -> Any:
-        from datetime import date, datetime, time
-        from decimal import Decimal
-        import uuid
-
-        if value is None:
-            return None
-        if isinstance(value, (str, int, float, bool)):
-            return value
-        if isinstance(value, Decimal):
-            return float(value)
-        if isinstance(value, datetime):
-            return value.isoformat()
-        if isinstance(value, date):
-            return value.isoformat()
-        if isinstance(value, time):
-            return value.isoformat()
-        if isinstance(value, uuid.UUID):
-            return str(value)
-        if hasattr(value, "field") and hasattr(value, "name"):
-            try:
-                return value.name or None
-            except (ValueError, AttributeError):
-                return None
-        return str(value)
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from flashapi.storage.base import Storage
+
+SOFT_DELETE_FIELD = "deleted_at"
+
+
+class DjangoORMStorage(Storage):
+    """Storage backend that delegates to Django's ORM."""
+
+    def __init__(self, model_class: type) -> None:
+        self._model = model_class
+        self._has_deleted_at = self._check_has_field(SOFT_DELETE_FIELD)
+
+    def _check_has_field(self, field_name: str) -> bool:
+        try:
+            self._model._meta.get_field(field_name)
+            return True
+        except Exception:
+            return False
+
+    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
+        instance = self._model.objects.create(**data)
+        return self._to_dict(instance)
+
+    def _get_instance(self, item_id, lookup_field="id"):
+        try:
+            if lookup_field == "id":
+                return self._model.objects.get(pk=item_id)
+            return self._model.objects.get(**{lookup_field: item_id})
+        except self._model.DoesNotExist:
+            return None
+
+    def get(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> dict[str, Any] | None:
+        instance = self._get_instance(item_id, lookup_field)
+        if instance is None:
+            return None
+        return self._to_dict(instance)
+
+    def list_all(self, table: str, *, include_deleted: bool = False, only_deleted: bool = False) -> list[dict[str, Any]]:
+        qs = self._model.objects.all()
+        if self._has_deleted_at:
+            if only_deleted:
+                qs = qs.filter(**{SOFT_DELETE_FIELD + "__isnull": False})
+            elif not include_deleted:
+                qs = qs.filter(**{SOFT_DELETE_FIELD + "__isnull": True})
+        return [self._to_dict(obj) for obj in qs]
+
+    def update(self, table: str, item_id: int | str, data: dict[str, Any], *, lookup_field: str = "id") -> dict[str, Any] | None:
+        instance = self._get_instance(item_id, lookup_field)
+        if instance is None:
+            return None
+
+        for key, value in data.items():
+            setattr(instance, key, value)
+        instance.save()
+        return self._to_dict(instance)
+
+    def delete(self, table: str, item_id: int | str, *, soft: bool = True, lookup_field: str = "id") -> bool:
+        instance = self._get_instance(item_id, lookup_field)
+        if instance is None:
+            return False
+        if soft and self._has_deleted_at:
+            if getattr(instance, SOFT_DELETE_FIELD, None) is not None:
+                return False
+            setattr(instance, SOFT_DELETE_FIELD, datetime.now(timezone.utc))
+            instance.save()
+        else:
+            instance.delete()
+        return True
+
+    def restore(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> bool:
+        if not self._has_deleted_at:
+            return False
+        instance = self._get_instance(item_id, lookup_field)
+        if instance is None:
+            return False
+        if getattr(instance, SOFT_DELETE_FIELD, None) is None:
+            return False
+        setattr(instance, SOFT_DELETE_FIELD, None)
+        instance.save()
+        return True
+
+    def _to_dict(self, instance) -> dict[str, Any]:
+
+        data = {}
+        for field in instance._meta.get_fields():
+            if field.many_to_many or field.one_to_many:
+                continue
+            if hasattr(field, "related_model") and field.related_model:
+                name = field.attname
+            else:
+                name = field.name
+            value = getattr(instance, name, None)
+            data[name] = self._serialize_value(value)
+        return data
+
+    def _serialize_value(self, value) -> Any:
+        import uuid
+        from datetime import date, datetime, time
+        from decimal import Decimal
+
+        if value is None:
+            return None
+        if isinstance(value, (str, int, float, bool)):
+            return value
+        if isinstance(value, Decimal):
+            return float(value)
+        if isinstance(value, datetime):
+            return value.isoformat()
+        if isinstance(value, date):
+            return value.isoformat()
+        if isinstance(value, time):
+            return value.isoformat()
+        if isinstance(value, uuid.UUID):
+            return str(value)
+        if hasattr(value, "field") and hasattr(value, "name"):
+            try:
+                return value.name or None
+            except (ValueError, AttributeError):
+                return None
+        return str(value)

flashapi/storage/sqlalchemy.py

@@ -1,24 +1,27 @@
 from __future__ import annotations
 
-from datetime import date, datetime, time
+from datetime import date, datetime, time, timezone
 from typing import Any
 
 from flashapi.storage.base import Storage
 
+SOFT_DELETE_FIELD = "deleted_at"
+
 
 class SQLAlchemyStorage(Storage):
     """Storage backend that delegates to a SQLAlchemy session."""
 
-    def __init__(self, session_factory, model_class: type):
+    def __init__(self, session_factory, model_class: type) -> None:
         self._session_factory = session_factory
         self._model = model_class
         self._column_types = {
             col.name: col.type for col in model_class.__table__.columns
         }
+        self._has_deleted_at = SOFT_DELETE_FIELD in self._column_types
 
     def _coerce_values(self, data: dict[str, Any]) -> dict[str, Any]:
         """Convert string values to proper Python types based on column definitions."""
-        from sqlalchemy import Date, DateTime, Time, Boolean
+        from sqlalchemy import Boolean, Date, DateTime, Time
 
         coerced = {}
         for key, value in data.items():
@@ -58,28 +61,43 @@ class SQLAlchemyStorage(Storage):
         finally:
             session.close()
 
-    def get(self, table: str, item_id: int | str) -> dict[str, Any] | None:
+    def _get_by_lookup(self, session, item_id, lookup_field="id"):
+        if lookup_field == "id":
+            return session.get(self._model, item_id)
+        col = getattr(self._model, lookup_field, None)
+        if col is None:
+            return None
+        return session.query(self._model).filter(col == item_id).first()
+
+    def get(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> dict[str, Any] | None:
         session = self._session_factory()
         try:
-            instance = session.get(self._model, item_id)
+            instance = self._get_by_lookup(session, item_id, lookup_field)
             if instance is None:
                 return None
             return self._to_dict(instance)
         finally:
             session.close()
 
-    def list_all(self, table: str) -> list[dict[str, Any]]:
+    def list_all(self, table: str, *, include_deleted: bool = False, only_deleted: bool = False) -> list[dict[str, Any]]:
         session = self._session_factory()
         try:
-            instances = session.query(self._model).all()
+            query = session.query(self._model)
+            if self._has_deleted_at:
+                col = getattr(self._model, SOFT_DELETE_FIELD)
+                if only_deleted:
+                    query = query.filter(col.isnot(None))
+                elif not include_deleted:
+                    query = query.filter(col.is_(None))
+            instances = query.all()
             return [self._to_dict(obj) for obj in instances]
         finally:
             session.close()
 
-    def update(self, table: str, item_id: int | str, data: dict[str, Any]) -> dict[str, Any] | None:
+    def update(self, table: str, item_id: int | str, data: dict[str, Any], *, lookup_field: str = "id") -> dict[str, Any] | None:
         session = self._session_factory()
         try:
-            instance = session.get(self._model, item_id)
+            instance = self._get_by_lookup(session, item_id, lookup_field)
             if instance is None:
                 return None
             for key, value in self._coerce_values(data).items():
@@ -93,13 +111,38 @@ class SQLAlchemyStorage(Storage):
         finally:
             session.close()
 
-    def delete(self, table: str, item_id: int | str) -> bool:
+    def delete(self, table: str, item_id: int | str, *, soft: bool = True, lookup_field: str = "id") -> bool:
+        session = self._session_factory()
+        try:
+            instance = self._get_by_lookup(session, item_id, lookup_field)
+            if instance is None:
+                return False
+            if soft and self._has_deleted_at:
+                if getattr(instance, SOFT_DELETE_FIELD, None) is not None:
+                    return False
+                setattr(instance, SOFT_DELETE_FIELD, datetime.now(timezone.utc))
+                session.commit()
+            else:
+                session.delete(instance)
+                session.commit()
+            return True
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def restore(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> bool:
+        if not self._has_deleted_at:
+            return False
         session = self._session_factory()
         try:
-            instance = session.get(self._model, item_id)
+            instance = self._get_by_lookup(session, item_id, lookup_field)
             if instance is None:
                 return False
-            session.delete(instance)
+            if getattr(instance, SOFT_DELETE_FIELD, None) is None:
+                return False
+            setattr(instance, SOFT_DELETE_FIELD, None)
             session.commit()
             return True
         except Exception:
@@ -116,9 +159,9 @@ class SQLAlchemyStorage(Storage):
         return data
 
     def _serialize_value(self, value) -> Any:
+        import uuid as uuid_mod
         from datetime import date, datetime, time
         from decimal import Decimal
-        import uuid as uuid_mod
 
         if value is None:
             return None