python-flashapi 0.1.0__py3-none-any.whl

flashapi/inspectors/pydantic.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from datetime import date, datetime, time
+from decimal import Decimal
+from typing import Any, get_origin, get_args
+from uuid import UUID
+
+from flashapi.core.schema import FieldSchema, FieldType, ModelSchema
+from flashapi.core.pluralize import pluralize
+from flashapi.inspectors.base import Inspector
+
+TYPE_MAP: dict[type, FieldType] = {
+    str: FieldType.STRING,
+    int: FieldType.INTEGER,
+    float: FieldType.FLOAT,
+    bool: FieldType.BOOLEAN,
+    datetime: FieldType.DATETIME,
+    date: FieldType.DATE,
+    time: FieldType.TIME,
+    UUID: FieldType.UUID,
+    Decimal: FieldType.FLOAT,
+    bytes: FieldType.BINARY,
+    dict: FieldType.JSON,
+    list: FieldType.JSON,
+}
+
+
+class PydanticInspector(Inspector):
+    def inspect(self, model_class: type, plural: str | None = None) -> ModelSchema:
+        from pydantic import BaseModel
+
+        if not issubclass(model_class, BaseModel):
+            raise TypeError(f"{model_class} is not a Pydantic model")
+
+        fields: list[FieldSchema] = []
+        fields.append(FieldSchema(name="id", type=FieldType.INTEGER, required=False, primary_key=True, auto_generated=True))
+
+        for name, field_info in model_class.model_fields.items():
+            field_type = self._resolve_type(field_info.annotation)
+            constraints = self._extract_constraints(field_info)
+            required = field_info.is_required()
+            default = field_info.default if not required else None
+
+            fields.append(FieldSchema(
+                name=name,
+                type=field_type,
+                required=required,
+                default=default,
+                constraints=constraints,
+            ))
+
+        model_name = model_class.__name__
+        plural_name = plural or pluralize(model_name)
+
+        return ModelSchema(name=model_name, plural=plural_name, fields=fields)
+
+    def _resolve_type(self, annotation: Any) -> FieldType:
+        if annotation is None:
+            return FieldType.STRING
+
+        origin = get_origin(annotation)
+        if origin is not None:
+            args = get_args(annotation)
+            non_none = [a for a in args if a is not type(None)]
+            if non_none:
+                annotation = non_none[0]
+            else:
+                return FieldType.STRING
+
+        return TYPE_MAP.get(annotation, FieldType.STRING)
+
+    def _extract_constraints(self, field_info: Any) -> dict:
+        constraints = {}
+        metadata = getattr(field_info, "metadata", [])
+        for m in metadata:
+            if hasattr(m, "max_length"):
+                constraints["max_length"] = m.max_length
+            if hasattr(m, "min_length"):
+                constraints["min_length"] = m.min_length
+            if hasattr(m, "ge"):
+                constraints["min_value"] = m.ge
+            if hasattr(m, "le"):
+                constraints["max_value"] = m.le
+        return constraints

flashapi/inspectors/sqlalchemy.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from flashapi.core.schema import FieldSchema, FieldType, ModelSchema, RelationSchema
+from flashapi.core.pluralize import pluralize
+from flashapi.inspectors.base import Inspector
+
+
+def _map_sa_type(col_type) -> FieldType:
+    type_name = type(col_type).__name__.upper()
+    mapping = {
+        "VARCHAR": FieldType.STRING,
+        "STRING": FieldType.STRING,
+        "TEXT": FieldType.TEXT,
+        "INTEGER": FieldType.INTEGER,
+        "BIGINTEGER": FieldType.INTEGER,
+        "SMALLINTEGER": FieldType.INTEGER,
+        "FLOAT": FieldType.FLOAT,
+        "NUMERIC": FieldType.FLOAT,
+        "BOOLEAN": FieldType.BOOLEAN,
+        "DATE": FieldType.DATE,
+        "DATETIME": FieldType.DATETIME,
+        "TIME": FieldType.TIME,
+        "UUID": FieldType.UUID,
+        "JSON": FieldType.JSON,
+        "BLOB": FieldType.BINARY,
+        "LARGEBINARY": FieldType.BINARY,
+    }
+    return mapping.get(type_name, FieldType.STRING)
+
+
+class SQLAlchemyInspector(Inspector):
+    def inspect(self, model_class: type, plural: str | None = None) -> ModelSchema:
+        table = model_class.__table__
+        fields: list[FieldSchema] = []
+
+        for col in table.columns:
+            field_type = _map_sa_type(col.type)
+            constraints = {}
+
+            if hasattr(col.type, "length") and col.type.length:
+                constraints["max_length"] = col.type.length
+
+            relation = None
+            if col.foreign_keys:
+                fk = next(iter(col.foreign_keys))
+                target_table = fk.column.table.name
+                relation = RelationSchema(type="many_to_one", target=target_table)
+
+            has_default = col.default is not None or col.server_default is not None
+            is_auto_int = (
+                col.primary_key
+                and col.autoincrement is not False
+                and field_type == FieldType.INTEGER
+            )
+            auto_generated = is_auto_int or (col.primary_key and has_default)
+
+            default_value = None
+            if col.default and not callable(getattr(col.default, "arg", None)):
+                default_value = col.default.arg
+
+            fields.append(FieldSchema(
+                name=col.name,
+                type=field_type,
+                required=not col.nullable and not col.primary_key and not has_default,
+                default=default_value,
+                constraints=constraints,
+                primary_key=col.primary_key,
+                auto_generated=auto_generated,
+                relation=relation,
+            ))
+
+        model_name = model_class.__name__
+        plural_name = plural or pluralize(model_name)
+
+        return ModelSchema(name=model_name, plural=plural_name, fields=fields)

flashapi/storage/__init__.py

@@ -0,0 +1,4 @@
+from flashapi.storage.base import Storage
+from flashapi.storage.auto import AutoStorage
+
+__all__ = ["Storage", "AutoStorage"]

flashapi/storage/auto.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import sqlite3
+from typing import Any
+
+from flashapi.core.schema import FieldType, ModelSchema
+from flashapi.storage.base import Storage
+
+FIELD_TYPE_TO_SQL = {
+    FieldType.STRING: "TEXT",
+    FieldType.INTEGER: "INTEGER",
+    FieldType.FLOAT: "REAL",
+    FieldType.BOOLEAN: "INTEGER",
+    FieldType.DATE: "TEXT",
+    FieldType.DATETIME: "TEXT",
+    FieldType.TIME: "TEXT",
+    FieldType.UUID: "TEXT",
+    FieldType.JSON: "TEXT",
+    FieldType.TEXT: "TEXT",
+    FieldType.BINARY: "BLOB",
+}
+
+
+def _validate_identifier(name: str) -> str:
+    """Validate and quote a SQL identifier to prevent injection."""
+    import re
+    if not re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name):
+        raise ValueError(f"Invalid SQL identifier: {name!r}")
+    return f'"{name}"'
+
+
+class AutoStorage(Storage):
+    """SQLite-backed automatic storage for Pydantic/dataclass models."""
+
+    def __init__(self, database: str = "flashapi.db"):
+        self._db_path = database
+        self._conn = sqlite3.connect(database, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._conn.execute("PRAGMA journal_mode=WAL")
+
+    def ensure_table(self, schema: ModelSchema) -> None:
+        table = _validate_identifier(schema.plural)
+        columns = []
+        for field in schema.fields:
+            col_name = _validate_identifier(field.name)
+            if field.primary_key:
+                columns.append(f"{col_name} INTEGER PRIMARY KEY AUTOINCREMENT")
+            else:
+                sql_type = FIELD_TYPE_TO_SQL.get(field.type, "TEXT")
+                not_null = " NOT NULL" if field.required else ""
+                columns.append(f"{col_name} {sql_type}{not_null}")
+
+        sql = f"CREATE TABLE IF NOT EXISTS {table} ({', '.join(columns)})"
+        self._conn.execute(sql)
+        self._conn.commit()
+
+    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
+        safe_table = _validate_identifier(table)
+        columns = [_validate_identifier(k) for k in data.keys()]
+        placeholders = ", ".join(["?"] * len(columns))
+        col_names = ", ".join(columns)
+        values = list(data.values())
+
+        cursor = self._conn.execute(
+            f"INSERT INTO {safe_table} ({col_names}) VALUES ({placeholders})", values
+        )
+        self._conn.commit()
+
+        item_id = cursor.lastrowid
+        return self.get(table, item_id)
+
+    def get(self, table: str, item_id: int | str) -> dict[str, Any] | None:
+        safe_table = _validate_identifier(table)
+        cursor = self._conn.execute(f"SELECT * FROM {safe_table} WHERE id = ?", (item_id,))
+        row = cursor.fetchone()
+        if row is None:
+            return None
+        return dict(row)
+
+    def list_all(self, table: str) -> list[dict[str, Any]]:
+        safe_table = _validate_identifier(table)
+        cursor = self._conn.execute(f"SELECT * FROM {safe_table}")
+        return [dict(row) for row in cursor.fetchall()]
+
+    def update(self, table: str, item_id: int | str, data: dict[str, Any]) -> dict[str, Any] | None:
+        if not self.get(table, item_id):
+            return None
+
+        safe_table = _validate_identifier(table)
+        set_clause = ", ".join([f"{_validate_identifier(k)} = ?" for k in data.keys()])
+        values = list(data.values()) + [item_id]
+
+        self._conn.execute(f"UPDATE {safe_table} SET {set_clause} WHERE id = ?", values)
+        self._conn.commit()
+        return self.get(table, item_id)
+
+    def delete(self, table: str, item_id: int | str) -> bool:
+        if not self.get(table, item_id):
+            return False
+        safe_table = _validate_identifier(table)
+        self._conn.execute(f"DELETE FROM {safe_table} WHERE id = ?", (item_id,))
+        self._conn.commit()
+        return True
+
+    def close(self) -> None:
+        self._conn.close()

flashapi/storage/base.py

@@ -0,0 +1,26 @@
+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:
+        ...

flashapi/storage/orm.py

@@ -0,0 +1,85 @@
+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)

flashapi/storage/sqlalchemy.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from datetime import date, datetime, time
+from typing import Any
+
+from flashapi.storage.base import Storage
+
+
+class SQLAlchemyStorage(Storage):
+    """Storage backend that delegates to a SQLAlchemy session."""
+
+    def __init__(self, session_factory, model_class: type):
+        self._session_factory = session_factory
+        self._model = model_class
+        self._column_types = {
+            col.name: col.type for col in model_class.__table__.columns
+        }
+
+    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
+
+        coerced = {}
+        for key, value in data.items():
+            if value is None:
+                coerced[key] = None
+                continue
+
+            col_type = self._column_types.get(key)
+            if col_type is None:
+                coerced[key] = value
+                continue
+
+            if isinstance(col_type, DateTime) and isinstance(value, str):
+                coerced[key] = datetime.fromisoformat(value)
+            elif isinstance(col_type, Date) and isinstance(value, str):
+                coerced[key] = date.fromisoformat(value)
+            elif isinstance(col_type, Time) and isinstance(value, str):
+                coerced[key] = time.fromisoformat(value)
+            elif isinstance(col_type, Boolean) and not isinstance(value, bool):
+                coerced[key] = bool(value)
+            else:
+                coerced[key] = value
+
+        return coerced
+
+    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
+        session = self._session_factory()
+        try:
+            instance = self._model(**self._coerce_values(data))
+            session.add(instance)
+            session.commit()
+            session.refresh(instance)
+            return self._to_dict(instance)
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def get(self, table: str, item_id: int | str) -> dict[str, Any] | None:
+        session = self._session_factory()
+        try:
+            instance = session.get(self._model, item_id)
+            if instance is None:
+                return None
+            return self._to_dict(instance)
+        finally:
+            session.close()
+
+    def list_all(self, table: str) -> list[dict[str, Any]]:
+        session = self._session_factory()
+        try:
+            instances = session.query(self._model).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:
+        session = self._session_factory()
+        try:
+            instance = session.get(self._model, item_id)
+            if instance is None:
+                return None
+            for key, value in self._coerce_values(data).items():
+                setattr(instance, key, value)
+            session.commit()
+            session.refresh(instance)
+            return self._to_dict(instance)
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def delete(self, table: str, item_id: int | str) -> bool:
+        session = self._session_factory()
+        try:
+            instance = session.get(self._model, item_id)
+            if instance is None:
+                return False
+            session.delete(instance)
+            session.commit()
+            return True
+        except Exception:
+            session.rollback()
+            raise
+        finally:
+            session.close()
+
+    def _to_dict(self, instance) -> dict[str, Any]:
+        data = {}
+        for col in instance.__table__.columns:
+            value = getattr(instance, col.name, None)
+            data[col.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 as uuid_mod
+
+        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_mod.UUID):
+            return str(value)
+        return str(value)