stackport 0.2.4__tar.gz → 0.2.6__tar.gz

{stackport-0.2.4/stackport.egg-info → stackport-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.2.4
+Version: 0.2.6
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.2.4 → stackport-0.2.6}/backend/main.py

@@ -58,11 +58,14 @@ class ReadOnlyMiddleware(BaseHTTPMiddleware):
 
     WRITE_METHODS = {"POST", "PUT", "DELETE", "PATCH"}
 
-    # POST endpoints that are read-only (query/invoke operations)
-    READ_ONLY_POST_PATTERNS = (
-        "/api/dynamodb/tables/",  # /tables/{name}/query
-        "/api/lambda/functions/",  # /functions/{name}/invoke
-    )
+    @staticmethod
+    def _is_read_only_post(path: str) -> bool:
+        """POST routes that are reads (not writes). Must not use path prefixes alone — e.g. item CRUD also lives under /api/dynamodb/tables/."""
+        if path.startswith("/api/dynamodb/tables/") and path.endswith("/query"):
+            return True
+        if path.startswith("/api/lambda/functions/") and path.endswith("/invoke"):
+            return True
+        return False
 
     async def dispatch(self, request: Request, call_next):
         if STACKPORT_ALLOW_WRITES:
@@ -74,10 +77,8 @@ class ReadOnlyMiddleware(BaseHTTPMiddleware):
 
         # Allow read-only POST operations (query, invoke)
         path = request.url.path
-        if request.method == "POST":
-            if any(path.startswith(p) for p in self.READ_ONLY_POST_PATTERNS):
-                # These are read operations that happen to use POST
-                return await call_next(request)
+        if request.method == "POST" and self._is_read_only_post(path):
+            return await call_next(request)
 
         # Block all write operations
         return JSONResponse(

{stackport-0.2.4 → stackport-0.2.6}/backend/routes/dynamodb.py

@@ -1,15 +1,75 @@
+import base64
+import json
 import logging
 from typing import Any
 
-from fastapi import APIRouter, Depends, Query
+from boto3.dynamodb.types import TypeSerializer
+from botocore.exceptions import ClientError
+from fastapi import APIRouter, Depends, HTTPException, Query
 
 from backend.aws_client import get_client
 from backend.cache import cache
 from backend.routes.common import get_endpoint_url
-from backend.schemas.dynamodb import QueryRequest
+from backend.schemas.dynamodb import BatchWriteRequest, DeleteItemRequest, PutItemRequest, QueryRequest
 
 logger = logging.getLogger(__name__)
 
+_serializer = TypeSerializer()
+
+
+def _plain_to_dynamodb_item(plain: dict[str, Any]) -> dict[str, Any]:
+    return {k: _serializer.serialize(v) for k, v in plain.items()}
+
+
+def _get_partition_sort_keys(dynamodb: Any, table_name: str) -> tuple[str | None, str | None]:
+    table_resp = dynamodb.describe_table(TableName=table_name)
+    key_schema = table_resp["Table"].get("KeySchema", [])
+    partition_key = next((k["AttributeName"] for k in key_schema if k["KeyType"] == "HASH"), None)
+    sort_key = next((k["AttributeName"] for k in key_schema if k["KeyType"] == "RANGE"), None)
+    return partition_key, sort_key
+
+
+def _require_key_attributes(
+    attrs: dict[str, Any],
+    partition_key: str | None,
+    sort_key: str | None,
+    *,
+    label: str,
+) -> None:
+    if not partition_key:
+        raise HTTPException(status_code=400, detail="Table has no partition key in key schema")
+    if partition_key not in attrs:
+        raise HTTPException(status_code=400, detail=f"Missing {label} attribute: {partition_key!r}")
+    if sort_key and sort_key not in attrs:
+        raise HTTPException(status_code=400, detail=f"Missing {label} attribute: {sort_key!r}")
+
+
+def _coerce_item_dict(raw: dict[str, Any], item_format: str) -> dict[str, Any]:
+    if item_format == "plain":
+        try:
+            return _plain_to_dynamodb_item(raw)
+        except TypeError as e:
+            raise HTTPException(status_code=400, detail=f"Could not convert plain item to DynamoDB types: {e}") from e
+    return raw
+
+
+def _coerce_key_dict(raw: dict[str, Any], item_format: str) -> dict[str, Any]:
+    if item_format == "plain":
+        try:
+            return _plain_to_dynamodb_item(raw)
+        except TypeError as e:
+            raise HTTPException(status_code=400, detail=f"Could not convert plain key to DynamoDB types: {e}") from e
+    return raw
+
+
+def _invalidate_table_item_count(table_name: str, endpoint_url: str | None) -> None:
+    cache.delete(f"{endpoint_url}:dynamodb:item_count:{table_name}")
+
+
+def _client_error_message(exc: ClientError) -> str:
+    err = exc.response.get("Error", {})
+    return err.get("Message", err.get("Code", str(exc)))
+
 router = APIRouter()
 
 
@@ -121,9 +181,6 @@ def scan_table(
     }
 
     if exclusive_start_key:
-        import base64
-        import json
-
         try:
             decoded = base64.b64decode(exclusive_start_key).decode("utf-8")
             scan_params["ExclusiveStartKey"] = json.loads(decoded)
@@ -137,9 +194,6 @@ def scan_table(
         last_evaluated_key = resp.get("LastEvaluatedKey")
         next_token = None
         if last_evaluated_key:
-            import base64
-            import json
-
             next_token = base64.b64encode(json.dumps(last_evaluated_key).encode("utf-8")).decode("utf-8")
 
         return {
@@ -212,3 +266,99 @@ def query_table(name: str, request: QueryRequest, endpoint_url: str | None = Dep
     except Exception as e:
         logger.error("Failed to query table %s: %s", name, e, exc_info=True)
         return {"error": str(e), "items": [], "count": 0}
+
+
+@router.api_route("/tables/{name}/items", methods=["POST", "PUT"])
+def put_table_item(
+    name: str,
+    request: PutItemRequest,
+    endpoint_url: str | None = Depends(get_endpoint_url),
+) -> dict[str, Any]:
+    """Create or replace an item (DynamoDB PutItem)."""
+    dynamodb = get_client("dynamodb", endpoint_url)
+    try:
+        partition_key, sort_key = _get_partition_sort_keys(dynamodb, name)
+    except Exception as e:
+        logger.error("put_item describe failed for %s: %s", name, e, exc_info=True)
+        raise HTTPException(status_code=400, detail=f"Failed to read table: {e}") from e
+
+    item = _coerce_item_dict(request.item, request.item_format)
+    _require_key_attributes(item, partition_key, sort_key, label="item")
+
+    try:
+        dynamodb.put_item(TableName=name, Item=item)
+    except ClientError as e:
+        msg = _client_error_message(e)
+        logger.error("put_item %s: %s", name, e, exc_info=True)
+        raise HTTPException(status_code=400, detail=msg) from e
+
+    _invalidate_table_item_count(name, endpoint_url)
+    return {"ok": True, "table": name}
+
+
+@router.delete("/tables/{name}/items")
+def delete_table_item(
+    name: str,
+    request: DeleteItemRequest,
+    endpoint_url: str | None = Depends(get_endpoint_url),
+) -> dict[str, Any]:
+    dynamodb = get_client("dynamodb", endpoint_url)
+    try:
+        partition_key, sort_key = _get_partition_sort_keys(dynamodb, name)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to read table: {e}") from e
+
+    key = _coerce_key_dict(request.key, request.item_format)
+    _require_key_attributes(key, partition_key, sort_key, label="key")
+
+    try:
+        dynamodb.delete_item(TableName=name, Key=key)
+    except ClientError as e:
+        msg = _client_error_message(e)
+        raise HTTPException(status_code=400, detail=msg) from e
+
+    _invalidate_table_item_count(name, endpoint_url)
+    return {"ok": True, "table": name}
+
+
+@router.post("/tables/{name}/items/batch")
+def batch_write_items(
+    name: str,
+    request: BatchWriteRequest,
+    endpoint_url: str | None = Depends(get_endpoint_url),
+) -> dict[str, Any]:
+    dynamodb = get_client("dynamodb", endpoint_url)
+    try:
+        partition_key, sort_key = _get_partition_sort_keys(dynamodb, name)
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to read table: {e}") from e
+
+    batch_requests: list[dict[str, Any]] = []
+    for op in request.operations:
+        if op.op == "put":
+            item = _coerce_item_dict(op.item, request.item_format)
+            _require_key_attributes(item, partition_key, sort_key, label="item")
+            batch_requests.append({"PutRequest": {"Item": item}})
+        else:
+            key = _coerce_key_dict(op.key, request.item_format)
+            _require_key_attributes(key, partition_key, sort_key, label="key")
+            batch_requests.append({"DeleteRequest": {"Key": key}})
+
+    try:
+        resp = dynamodb.batch_write_item(RequestItems={name: batch_requests})
+    except ClientError as e:
+        msg = _client_error_message(e)
+        raise HTTPException(status_code=400, detail=msg) from e
+
+    _invalidate_table_item_count(name, endpoint_url)
+
+    uproc = resp.get("UnprocessedItems", {})
+    if uproc:
+        return {
+            "ok": True,
+            "table": name,
+            "unprocessed": uproc,
+            "message": "Some items were not processed; retry with returned keys.",
+        }
+
+    return {"ok": True, "table": name, "unprocessed": {}}