stackport 0.3.0__tar.gz → 0.3.2__tar.gz

{stackport-0.3.0/stackport.egg-info → stackport-0.3.2}/PKG-INFO

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

{stackport-0.3.0 → stackport-0.3.2}/backend/routes/lambda_svc.py

@@ -9,6 +9,7 @@ from fastapi.responses import RedirectResponse
 
 from backend.aws_client import get_client
 from backend.routes.common import EndpointInfo, get_endpoint_info
+from backend.schemas.lambda_svc import UpdateFunctionConfigRequest
 
 router = APIRouter()
 
@@ -184,3 +185,54 @@ def list_versions(function_name: str, ep: EndpointInfo = Depends(get_endpoint_in
         return {"versions": versions}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/functions/{function_name}/configuration")
+def update_function_configuration(
+    function_name: str,
+    body: UpdateFunctionConfigRequest,
+    ep: EndpointInfo = Depends(get_endpoint_info)
+) -> dict[str, Any]:
+    """Update Lambda function configuration (partial updates supported).
+
+    All body fields are optional — only specified fields will be updated.
+    Returns the updated function configuration.
+    """
+    try:
+        client = get_client("lambda", **ep.client_kwargs())
+
+        # Build boto3 kwargs from request body, skipping None values
+        update_kwargs: dict[str, Any] = {"FunctionName": function_name}
+
+        if body.description is not None:
+            update_kwargs["Description"] = body.description
+
+        if body.handler is not None:
+            update_kwargs["Handler"] = body.handler
+
+        if body.runtime is not None:
+            update_kwargs["Runtime"] = body.runtime
+
+        if body.memory_size is not None:
+            update_kwargs["MemorySize"] = body.memory_size
+
+        if body.timeout is not None:
+            update_kwargs["Timeout"] = body.timeout
+
+        if body.environment is not None:
+            update_kwargs["Environment"] = {"Variables": body.environment}
+
+        if body.layers is not None:
+            update_kwargs["Layers"] = body.layers
+
+        # Call update_function_configuration
+        response = client.update_function_configuration(**update_kwargs)
+
+        return {"configuration": response}
+
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Function {function_name} not found")
+    except client.exceptions.InvalidParameterValueException as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

stackport-0.3.2/backend/routes/secretsmanager.py

@@ -0,0 +1,256 @@
+"""Secrets Manager service-specific routes."""
+
+import base64
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from backend.aws_client import get_client
+from backend.routes.common import EndpointInfo, get_endpoint_info
+from backend.schemas.secretsmanager import (
+    CreateSecretBody,
+    UpdateSecretMetadataBody,
+    UpdateSecretValueBody,
+)
+
+router = APIRouter()
+
+
+def _format_date(dt) -> str | None:
+    """Format a datetime to ISO string, or return None."""
+    if dt is None:
+        return None
+    try:
+        return dt.isoformat()
+    except Exception:
+        return str(dt)
+
+
+@router.get("/secrets")
+def list_secrets(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all secrets with metadata."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+        paginator = client.get_paginator("list_secrets")
+
+        secrets = []
+        for page in paginator.paginate():
+            for secret in page.get("SecretList", []):
+                secrets.append(
+                    {
+                        "name": secret.get("Name"),
+                        "arn": secret.get("ARN"),
+                        "description": secret.get("Description", ""),
+                        "createdDate": _format_date(secret.get("CreatedDate")),
+                        "lastChangedDate": _format_date(
+                            secret.get("LastChangedDate")
+                        ),
+                        "lastAccessedDate": _format_date(
+                            secret.get("LastAccessedDate")
+                        ),
+                        "rotationEnabled": secret.get("RotationEnabled", False),
+                        "tags": {
+                            tag["Key"]: tag["Value"]
+                            for tag in secret.get("Tags", [])
+                        },
+                    }
+                )
+
+        return {"secrets": secrets}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/secrets/{secret_id:path}")
+def get_secret_detail(secret_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get secret metadata and value."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        # Get metadata
+        try:
+            meta = client.describe_secret(SecretId=secret_id)
+        except client.exceptions.ResourceNotFoundException:
+            raise HTTPException(
+                status_code=404, detail=f"Secret '{secret_id}' not found"
+            )
+
+        # Get value
+        secret_value = None
+        secret_binary = None
+        version_id = None
+        version_stages = None
+        try:
+            value_resp = client.get_secret_value(SecretId=secret_id)
+            secret_value = value_resp.get("SecretString")
+            raw_binary = value_resp.get("SecretBinary")
+            if raw_binary is not None:
+                secret_binary = base64.b64encode(raw_binary).decode("utf-8")
+            version_id = value_resp.get("VersionId")
+            version_stages = value_resp.get("VersionStages")
+        except Exception:
+            # Value may not be retrievable (e.g., pending deletion)
+            pass
+
+        return {
+            "name": meta.get("Name"),
+            "arn": meta.get("ARN"),
+            "description": meta.get("Description", ""),
+            "createdDate": _format_date(meta.get("CreatedDate")),
+            "lastChangedDate": _format_date(meta.get("LastChangedDate")),
+            "lastAccessedDate": _format_date(meta.get("LastAccessedDate")),
+            "rotationEnabled": meta.get("RotationEnabled", False),
+            "rotationRules": meta.get("RotationRules"),
+            "rotationLambdaARN": meta.get("RotationLambdaARN"),
+            "deletedDate": _format_date(meta.get("DeletedDate")),
+            "tags": {
+                tag["Key"]: tag["Value"]
+                for tag in meta.get("Tags", [])
+            },
+            "versionId": version_id,
+            "versionStages": version_stages,
+            "secretValue": secret_value,
+            "secretBinary": secret_binary,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/secrets", status_code=201)
+def create_secret(body: CreateSecretBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Create a new secret."""
+    if not body.secret_string and not body.secret_binary:
+        raise HTTPException(status_code=400, detail="Must provide either secret_string or secret_binary")
+
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"Name": body.name}
+        if body.description:
+            kwargs["Description"] = body.description
+        if body.secret_string:
+            kwargs["SecretString"] = body.secret_string
+        if body.secret_binary:
+            kwargs["SecretBinary"] = base64.b64decode(body.secret_binary)
+        if body.tags:
+            kwargs["Tags"] = [{"Key": k, "Value": v} for k, v in body.tags.items()]
+
+        resp = client.create_secret(**kwargs)
+        return {
+            "name": resp["Name"],
+            "arn": resp["ARN"],
+            "versionId": resp.get("VersionId"),
+        }
+    except client.exceptions.ResourceExistsException:
+        raise HTTPException(status_code=409, detail=f"Secret '{body.name}' already exists")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/secrets/{secret_id:path}/value")
+def update_secret_value(secret_id: str, body: UpdateSecretValueBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Update a secret's value."""
+    if not body.secret_string and not body.secret_binary:
+        raise HTTPException(status_code=400, detail="Must provide either secret_string or secret_binary")
+
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"SecretId": secret_id}
+        if body.secret_string:
+            kwargs["SecretString"] = body.secret_string
+        if body.secret_binary:
+            kwargs["SecretBinary"] = base64.b64decode(body.secret_binary)
+
+        resp = client.put_secret_value(**kwargs)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+            "versionId": resp["VersionId"],
+            "versionStages": resp.get("VersionStages"),
+        }
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/secrets/{secret_id:path}/metadata")
+def update_secret_metadata(secret_id: str, body: UpdateSecretMetadataBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Update a secret's description and/or tags."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        # Update description
+        if body.description is not None:
+            client.update_secret(SecretId=secret_id, Description=body.description)
+
+        # Update tags (replace all)
+        if body.tags is not None:
+            arn = client.describe_secret(SecretId=secret_id)["ARN"]
+            # Remove all existing tags first
+            existing_tags_resp = client.describe_secret(SecretId=secret_id)
+            existing_tag_keys = [tag["Key"] for tag in existing_tags_resp.get("Tags", [])]
+            if existing_tag_keys:
+                client.untag_resource(SecretId=arn, TagKeys=existing_tag_keys)
+            # Add new tags
+            if body.tags:
+                client.tag_resource(
+                    SecretId=arn,
+                    Tags=[{"Key": k, "Value": v} for k, v in body.tags.items()],
+                )
+
+        return {"success": True, "message": "Metadata updated"}
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/secrets/{secret_id:path}")
+def delete_secret(
+    secret_id: str,
+    force: bool = Query(False, description="Skip recovery window (immediate deletion)"),
+    ep: EndpointInfo = Depends(get_endpoint_info),
+) -> dict[str, Any]:
+    """Delete a secret."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"SecretId": secret_id}
+        if force:
+            kwargs["ForceDeleteWithoutRecovery"] = True
+        else:
+            kwargs["RecoveryWindowInDays"] = 7
+
+        resp = client.delete_secret(**kwargs)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+            "deletionDate": _format_date(resp.get("DeletionDate")),
+        }
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/secrets/{secret_id:path}/restore")
+def restore_secret(secret_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Restore a deleted secret."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+        resp = client.restore_secret(SecretId=secret_id)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+        }
+    except Exception as e:
+        error_code = getattr(e, "response", {}).get("Error", {}).get("Code", "")
+        if error_code == "ResourceNotFoundException":
+            raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+        elif error_code == "InvalidRequestException":
+            raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e))

stackport-0.3.2/backend/schemas/lambda_svc.py

@@ -0,0 +1,23 @@
+"""Pydantic schemas for Lambda API requests."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UpdateFunctionConfigRequest(BaseModel):
+    """Request body for updating Lambda function configuration.
+
+    All fields are optional — only specified fields will be updated.
+    Validation follows AWS Lambda limits:
+    - Memory: 128-10240 MB
+    - Timeout: 1-900 seconds
+    """
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    description: str | None = Field(None, description="Function description")
+    handler: str | None = Field(None, description="Handler path (e.g., index.handler)")
+    runtime: str | None = Field(None, description="Runtime identifier (e.g., python3.12, nodejs20.x)")
+    memory_size: int | None = Field(None, alias="memorySize", ge=128, le=10240, description="Memory in MB")
+    timeout: int | None = Field(None, ge=1, le=900, description="Timeout in seconds")
+    environment: dict[str, str] | None = Field(None, description="Environment variables as key-value dict")
+    layers: list[str] | None = Field(None, description="Layer ARNs")

stackport-0.3.2/backend/schemas/secretsmanager.py

@@ -0,0 +1,33 @@
+"""Pydantic schemas for Secrets Manager API requests."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CreateSecretBody(BaseModel):
+    """Request body for creating a new secret."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str = Field(..., description="Secret name")
+    description: str | None = Field(None, description="Secret description")
+    secret_string: str | None = Field(None, alias="secretString", description="Secret value as string")
+    secret_binary: str | None = Field(None, alias="secretBinary", description="Secret value as base64-encoded binary")
+    tags: dict[str, str] = Field(default_factory=dict, description="Resource tags")
+
+
+class UpdateSecretValueBody(BaseModel):
+    """Request body for updating a secret's value."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    secret_string: str | None = Field(None, alias="secretString", description="New secret value as string")
+    secret_binary: str | None = Field(None, alias="secretBinary", description="New secret value as base64-encoded binary")
+
+
+class UpdateSecretMetadataBody(BaseModel):
+    """Request body for updating a secret's metadata."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    description: str | None = Field(None, description="New description")
+    tags: dict[str, str] | None = Field(None, description="New tags (replaces existing)")

{stackport-0.3.0 → stackport-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackport"
-version = "0.3.0"
+version = "0.3.2"
 description = "Universal AWS resource browser for local emulators"
 readme = "README.md"
 license = {text = "MIT"}

{stackport-0.3.0 → stackport-0.3.2/stackport.egg-info}/PKG-INFO

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

{stackport-0.3.0 → stackport-0.3.2}/stackport.egg-info/SOURCES.txt

@@ -13,8 +13,8 @@ backend/websocket.py
 backend/../ui/dist/favicon.png
 backend/../ui/dist/favicon.svg
 backend/../ui/dist/index.html
-backend/../ui/dist/assets/index-Cda_0qu5.css
-backend/../ui/dist/assets/index-tW-8e4eS.js
+backend/../ui/dist/assets/index-BJ2zUhqY.css
+backend/../ui/dist/assets/index-D8i-Md_b.js
 backend/../ui/dist/aws-icons/acm.svg
 backend/../ui/dist/aws-icons/apigateway.svg
 backend/../ui/dist/aws-icons/appsync.svg
@@ -66,7 +66,9 @@ backend/routes/tags.py
 backend/schemas/__init__.py
 backend/schemas/dynamodb.py
 backend/schemas/endpoints.py
+backend/schemas/lambda_svc.py
 backend/schemas/s3.py
+backend/schemas/secretsmanager.py
 backend/schemas/sqs.py
 backend/schemas/tags.py
 stackport.egg-info/PKG-INFO
@@ -99,8 +101,8 @@ tests/test_websocket.py
 ui/dist/favicon.png
 ui/dist/favicon.svg
 ui/dist/index.html
-ui/dist/assets/index-Cda_0qu5.css
-ui/dist/assets/index-tW-8e4eS.js
+ui/dist/assets/index-BJ2zUhqY.css
+ui/dist/assets/index-D8i-Md_b.js
 ui/dist/aws-icons/acm.svg
 ui/dist/aws-icons/apigateway.svg
 ui/dist/aws-icons/appsync.svg

{stackport-0.3.0 → stackport-0.3.2}/tests/test_lambda_routes.py

@@ -269,3 +269,184 @@ class TestListVersions:
         data = resp.json()
         assert len(data["versions"]) == 2
         assert data["versions"][0]["Version"] == "$LATEST"
+
+
+class TestUpdateFunctionConfiguration:
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_environment_variables(self, mock_get_client):
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        mock_lambda.update_function_configuration.return_value = {
+            "FunctionName": "my-func",
+            "Runtime": "python3.12",
+            "Handler": "handler.main",
+            "MemorySize": 256,
+            "Timeout": 30,
+            "Environment": {
+                "Variables": {
+                    "KEY1": "value1",
+                    "KEY2": "value2",
+                }
+            },
+        }
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={
+                "environment": {
+                    "KEY1": "value1",
+                    "KEY2": "value2",
+                }
+            },
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["configuration"]["Environment"]["Variables"]["KEY1"] == "value1"
+        mock_lambda.update_function_configuration.assert_called_once()
+        call_args = mock_lambda.update_function_configuration.call_args[1]
+        assert call_args["FunctionName"] == "my-func"
+        assert call_args["Environment"]["Variables"] == {"KEY1": "value1", "KEY2": "value2"}
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_memory_and_timeout(self, mock_get_client):
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        mock_lambda.update_function_configuration.return_value = {
+            "FunctionName": "my-func",
+            "MemorySize": 512,
+            "Timeout": 60,
+        }
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"memorySize": 512, "timeout": 60},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["configuration"]["MemorySize"] == 512
+        assert data["configuration"]["Timeout"] == 60
+        mock_lambda.update_function_configuration.assert_called_once_with(
+            FunctionName="my-func",
+            MemorySize=512,
+            Timeout=60,
+        )
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_handler_and_runtime(self, mock_get_client):
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        mock_lambda.update_function_configuration.return_value = {
+            "FunctionName": "my-func",
+            "Handler": "new_handler.handler",
+            "Runtime": "python3.13",
+        }
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"handler": "new_handler.handler", "runtime": "python3.13"},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["configuration"]["Handler"] == "new_handler.handler"
+        assert data["configuration"]["Runtime"] == "python3.13"
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_description(self, mock_get_client):
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        mock_lambda.update_function_configuration.return_value = {
+            "FunctionName": "my-func",
+            "Description": "Updated description",
+        }
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"description": "Updated description"},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["configuration"]["Description"] == "Updated description"
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_partial(self, mock_get_client):
+        """Test that only specified fields are included in the update call."""
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        mock_lambda.update_function_configuration.return_value = {
+            "FunctionName": "my-func",
+            "Timeout": 120,
+        }
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"timeout": 120},
+        )
+        assert resp.status_code == 200
+        # Verify only Timeout and FunctionName were passed
+        mock_lambda.update_function_configuration.assert_called_once()
+        call_args = mock_lambda.update_function_configuration.call_args[1]
+        assert set(call_args.keys()) == {"FunctionName", "Timeout"}
+        assert call_args["Timeout"] == 120
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_function_not_found(self, mock_get_client):
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        # Set up both exception types
+        mock_lambda.exceptions.ResourceNotFoundException = type("ResourceNotFoundException", (Exception,), {})
+        mock_lambda.exceptions.InvalidParameterValueException = type("InvalidParameterValueException", (Exception,), {})
+        mock_lambda.update_function_configuration.side_effect = mock_lambda.exceptions.ResourceNotFoundException()
+
+        resp = client.patch(
+            "/api/lambda/functions/nonexistent/configuration",
+            json={"timeout": 60},
+        )
+        assert resp.status_code == 404
+
+    @patch("backend.routes.lambda_svc.get_client")
+    def test_update_invalid_parameter_boto3(self, mock_get_client):
+        """Test AWS InvalidParameterValueException returns 400."""
+        mock_lambda = MagicMock()
+        mock_get_client.return_value = mock_lambda
+        # Set up both exception types
+        mock_lambda.exceptions.ResourceNotFoundException = type("ResourceNotFoundException", (Exception,), {})
+        mock_lambda.exceptions.InvalidParameterValueException = type("InvalidParameterValueException", (Exception,), {})
+        mock_lambda.update_function_configuration.side_effect = mock_lambda.exceptions.InvalidParameterValueException("Invalid runtime")
+
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"runtime": "invalid_runtime"},
+        )
+        assert resp.status_code == 400
+
+    def test_update_validation_memory_too_low(self):
+        """Test Pydantic validation rejects memory < 128."""
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"memorySize": 64},
+        )
+        assert resp.status_code == 422
+
+    def test_update_validation_memory_too_high(self):
+        """Test Pydantic validation rejects memory > 10240."""
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"memorySize": 20480},
+        )
+        assert resp.status_code == 422
+
+    def test_update_validation_timeout_too_low(self):
+        """Test Pydantic validation rejects timeout < 1."""
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"timeout": 0},
+        )
+        assert resp.status_code == 422
+
+    def test_update_validation_timeout_too_high(self):
+        """Test Pydantic validation rejects timeout > 900."""
+        resp = client.patch(
+            "/api/lambda/functions/my-func/configuration",
+            json={"timeout": 1000},
+        )
+        assert resp.status_code == 422