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

flashapi/inspectors/pydantic.py

@@ -1,84 +1,99 @@
-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
+from __future__ import annotations
+
+from datetime import date, datetime, time
+from decimal import Decimal
+from typing import Any, get_args, get_origin
+from uuid import UUID
+
+from flashapi.core.pluralize import pluralize
+from flashapi.core.schema import FieldSchema, FieldType, ModelSchema
+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):
+            msg = f"{model_class} is not a Pydantic model"
+            raise TypeError(msg)
+
+        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
+            visibility = self._extract_visibility(field_info)
+
+            fields.append(FieldSchema(
+                name=name,
+                type=field_type,
+                required=required,
+                default=default,
+                constraints=constraints,
+                **visibility,
+            ))
+
+        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
+
+    def _extract_visibility(self, field_info: Any) -> dict:
+        visibility = {}
+        extra = getattr(field_info, "json_schema_extra", None) or {}
+        flash = extra.get("flash", {}) if isinstance(extra, dict) else {}
+        for key in ("readonly", "writeonly", "hidden", "export_exclude"):
+            if flash.get(key):
+                visibility[key] = True
+        if flash.get("auto"):
+            visibility["auto"] = flash["auto"]
+            visibility["auto_generated"] = True
+        return visibility

flashapi/inspectors/sqlalchemy.py

@@ -1,75 +1,83 @@
-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)
+from __future__ import annotations
+
+from flashapi.core.pluralize import pluralize
+from flashapi.core.schema import FieldSchema, FieldType, ModelSchema, RelationSchema
+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
+            has_callable_default = col.default is not None and callable(getattr(col.default, "arg", 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) or has_callable_default
+
+            default_value = None
+            if col.default and not callable(getattr(col.default, "arg", None)):
+                default_value = col.default.arg
+
+            visibility = {}
+            info = getattr(col, "info", {}) or {}
+            for key in ("readonly", "writeonly", "hidden", "export_exclude"):
+                if info.get(key):
+                    visibility[key] = True
+
+            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,
+                **visibility,
+            ))
+
+        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

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

flashapi/storage/auto.py

@@ -1,106 +1,189 @@
-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()
+from __future__ import annotations
+
+import sqlite3
+from datetime import datetime, timezone
+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):
+        msg = f"Invalid SQL identifier: {name!r}"
+        raise ValueError(msg)
+    return f'"{name}"'
+
+
+class AutoStorage(Storage):
+    """SQLite-backed automatic storage with soft-delete support."""
+
+    def __init__(self, database: str = "flashapi.db") -> None:
+        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")
+        self._soft_delete_tables: set[str] = set()
+        self._auto_fields: dict[str, list[tuple[str, str]]] = {}  # table -> [(field_name, auto_type)]
+
+    def ensure_table(self, schema: ModelSchema, *, soft_delete: bool = True) -> 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}")
+
+        if soft_delete:
+            columns.append('"deleted_at" TEXT')
+            self._soft_delete_tables.add(schema.plural)
+
+        auto_fields = [(f.name, f.auto) for f in schema.fields if f.auto]
+        if auto_fields:
+            self._auto_fields[schema.plural] = auto_fields
+
+        sql = f"CREATE TABLE IF NOT EXISTS {table} ({', '.join(columns)})"
+        self._conn.execute(sql)
+        self._conn.commit()
+
+    def _generate_auto_value(self, auto_type: str) -> Any:
+        import uuid
+        if auto_type == "uuid":
+            return str(uuid.uuid4())
+        if auto_type == "datetime":
+            return datetime.now(timezone.utc).isoformat()
+        if auto_type == "date":
+            return datetime.now(timezone.utc).date().isoformat()
+        return None
+
+    def create(self, table: str, data: dict[str, Any]) -> dict[str, Any]:
+        data = dict(data)
+        for field_name, auto_type in self._auto_fields.get(table, []):
+            if field_name not in data:
+                data[field_name] = self._generate_auto_value(auto_type)
+
+        safe_table = _validate_identifier(table)
+        columns = [_validate_identifier(k) for k in data]
+        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_raw(table, item_id)
+
+    def get(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> dict[str, Any] | None:
+        row = self._get_raw(table, item_id, lookup_field=lookup_field)
+        if row is None:
+            return None
+        if table in self._soft_delete_tables and row.get("deleted_at"):
+            return None
+        return self._strip_internal(row, table)
+
+    def _get_raw(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> dict[str, Any] | None:
+        safe_table = _validate_identifier(table)
+        safe_field = _validate_identifier(lookup_field)
+        cursor = self._conn.execute(f"SELECT * FROM {safe_table} WHERE {safe_field} = ?", (item_id,))
+        row = cursor.fetchone()
+        if row is None:
+            return None
+        return dict(row)
+
+    def list_all(self, table: str, *, include_deleted: bool = False, only_deleted: bool = False) -> list[dict[str, Any]]:
+        safe_table = _validate_identifier(table)
+        if table in self._soft_delete_tables:
+            if only_deleted:
+                cursor = self._conn.execute(
+                    f"SELECT * FROM {safe_table} WHERE deleted_at IS NOT NULL",
+                )
+            elif not include_deleted:
+                cursor = self._conn.execute(
+                    f"SELECT * FROM {safe_table} WHERE deleted_at IS NULL",
+                )
+            else:
+                cursor = self._conn.execute(f"SELECT * FROM {safe_table}")
+        else:
+            cursor = self._conn.execute(f"SELECT * FROM {safe_table}")
+        return [self._strip_internal(dict(row), table) for row in cursor.fetchall()]
+
+    def update(self, table: str, item_id: int | str, data: dict[str, Any], *, lookup_field: str = "id") -> dict[str, Any] | None:
+        if not self.get(table, item_id, lookup_field=lookup_field):
+            return None
+
+        safe_table = _validate_identifier(table)
+        safe_field = _validate_identifier(lookup_field)
+        set_clause = ", ".join([f"{_validate_identifier(k)} = ?" for k in data])
+        values = [*list(data.values()), item_id]
+
+        self._conn.execute(f"UPDATE {safe_table} SET {set_clause} WHERE {safe_field} = ?", values)
+        self._conn.commit()
+        return self.get(table, item_id, lookup_field=lookup_field)
+
+    def delete(self, table: str, item_id: int | str, *, soft: bool = True, lookup_field: str = "id") -> bool:
+        raw = self._get_raw(table, item_id, lookup_field=lookup_field)
+        if raw is None:
+            return False
+        if table in self._soft_delete_tables and raw.get("deleted_at"):
+            return False
+
+        safe_table = _validate_identifier(table)
+        safe_field = _validate_identifier(lookup_field)
+        if soft and table in self._soft_delete_tables:
+            now = datetime.now(timezone.utc).isoformat()
+            self._conn.execute(
+                f"UPDATE {safe_table} SET deleted_at = ? WHERE {safe_field} = ?", (now, item_id),
+            )
+        else:
+            self._conn.execute(f"DELETE FROM {safe_table} WHERE {safe_field} = ?", (item_id,))
+        self._conn.commit()
+        return True
+
+    def restore(self, table: str, item_id: int | str, *, lookup_field: str = "id") -> bool:
+        if table not in self._soft_delete_tables:
+            return False
+        raw = self._get_raw(table, item_id, lookup_field=lookup_field)
+        if raw is None or not raw.get("deleted_at"):
+            return False
+
+        safe_table = _validate_identifier(table)
+        safe_field = _validate_identifier(lookup_field)
+        self._conn.execute(
+            f"UPDATE {safe_table} SET deleted_at = NULL WHERE {safe_field} = ?", (item_id,),
+        )
+        self._conn.commit()
+        return True
+
+    def bulk_create(self, table: str, items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        return [self.create(table, item) for item in items]
+
+    def _strip_internal(self, row: dict, table: str) -> dict:
+        if table in self._soft_delete_tables:
+            row.pop("deleted_at", None)
+        return row
+
+    def close(self) -> None:
+        self._conn.close()