stackport 0.3.4__tar.gz → 0.3.6__tar.gz

{stackport-0.3.4/stackport.egg-info → stackport-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.3.4
+Version: 0.3.6
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT
@@ -29,6 +29,7 @@ Requires-Dist: websockets>=12.0
 Requires-Dist: python-multipart>=0.0.26
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
 Requires-Dist: httpx>=0.27.0; extra == "dev"
 Requires-Dist: moto[dynamodb,iam,lambda,s3,sqs]>=5.0; extra == "dev"
 Dynamic: license-file

{stackport-0.3.4 → stackport-0.3.6}/backend/main.py

@@ -17,7 +17,7 @@ from botocore.exceptions import (
 )
 
 from backend.config import LOG_LEVEL, STACKPORT_ALLOW_WRITES, STACKPORT_PORT
-from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, resources, s3, secretsmanager, sqs, stats, stepfunctions, tags
+from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, resources, rds, s3, secretsmanager, sqs, stats, stepfunctions, tags
 from backend.websocket import probe_loop, websocket_endpoint
 
 
@@ -120,12 +120,13 @@ app.include_router(dynamodb.router, prefix="/api/dynamodb")
 app.include_router(lambda_svc.router, prefix="/api/lambda", tags=["lambda"])
 app.include_router(sqs.router, prefix="/api/sqs", tags=["sqs"])
 app.include_router(iam.router, prefix="/api/iam", tags=["iam"])
-app.include_router(ec2.router, prefix="/api/ec2", tags=["ec2"])
+app.include_router(ec2.router, prefix="/api/ec2", tags=["ec2", "autoscaling"])
 app.include_router(logs.router, prefix="/api/logs", tags=["logs"])
 app.include_router(secretsmanager.router, prefix="/api/secretsmanager", tags=["secretsmanager"])
 app.include_router(stepfunctions.router, prefix="/api/stepfunctions", tags=["stepfunctions"])
 app.include_router(tags.router, prefix="/api", tags=["tags"])
 app.include_router(resources.router, prefix="/api")
+app.include_router(rds.router, prefix="/api/rds", tags=["rds"])
 
 
 # WebSocket endpoint for real-time updates

{stackport-0.3.4 → stackport-0.3.6}/backend/routes/ec2.py

@@ -38,6 +38,49 @@ def _decode_user_data(encoded: str | None) -> str | None:
     except Exception:
         return None
 
+def _map_asg_instance(inst: dict) -> dict:
+    """Map an Auto Scaling Group instance to a camelCase shape."""
+    return {
+        "instanceId": inst.get("InstanceId"),
+        "instanceType": inst.get("InstanceType"),
+        "lifecycleState": inst.get("LifecycleState"),
+        "healthStatus": inst.get("HealthStatus"),
+        "availabilityZone": inst.get("AvailabilityZone"),
+    }
+
+
+@router.get("/asgs")
+def list_autoscaling_groups(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all Auto Scaling Groups with their instances."""
+    try:
+        client = get_client("autoscaling", **ep.client_kwargs())
+        paginator = client.get_paginator("describe_auto_scaling_groups")
+
+        all_groups = []
+        for page in paginator.paginate():
+            for group in page.get("AutoScalingGroups", []):
+                created_time = group.get("CreatedTime")
+                instances = group.get("Instances", [])
+                all_groups.append(
+                    {
+                        "autoScalingGroupARN": group["AutoScalingGroupARN"],
+                        "autoScalingGroupName": group["AutoScalingGroupName"],
+                        "createdTime": created_time.isoformat() if created_time else None,
+                        "desiredCapacity": group["DesiredCapacity"],
+                        "maxSize": group["MaxSize"],
+                        "minSize": group["MinSize"],
+                        "availabilityZones": group.get("AvailabilityZones", []),
+                        "healthCheckGracePeriod": group.get("HealthCheckGracePeriod", 0),
+                        "instanceCount": len(instances),
+                        "instances": [_map_asg_instance(i) for i in instances],
+                        "loadBalancerNames": group.get("LoadBalancerNames", []),
+                        "tags": group.get("Tags", []),
+                    }
+                )
+        return {"auto_scaling_groups": all_groups}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 
 @router.get("/instances")
 def list_instances(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:

stackport-0.3.6/backend/routes/rds.py

@@ -0,0 +1,447 @@
+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
+
+router = APIRouter()
+
+
+def _flatten_db_instances(response: dict) -> list[dict]:
+    """Extract DBInstances from describe_db_instances response."""
+    return response.get("DBInstances", [])
+
+
+def _flatten_db_clusters(response: dict) -> list[dict]:
+    """Extract DBClusters from describe_db_clusters response."""
+    return response.get("DBClusters", [])
+
+
+def _get_endpoint_address(instance: dict) -> str:
+    """Get the endpoint address from an RDS instance."""
+    endpoint = instance.get("Endpoint", {})
+    if isinstance(endpoint, dict):
+        return endpoint.get("Address", "")
+    return ""
+
+
+def _get_endpoint_port(instance: dict) -> int:
+    """Get the endpoint port from an RDS instance."""
+    endpoint = instance.get("Endpoint", {})
+    if isinstance(endpoint, dict):
+        return endpoint.get("Port", 0)
+    return 0
+
+
+def _get_reader_endpoint_address(cluster: dict) -> str:
+    """Get the reader endpoint address from an RDS cluster."""
+    endpoint = cluster.get("ReaderEndpoint", "")
+    return endpoint if isinstance(endpoint, str) else ""
+
+
+@router.get("/instances")
+def list_db_instances(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all RDS DB instances with enriched metadata."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+        paginator = client.get_paginator("describe_db_instances")
+
+        all_instances = []
+        for page in paginator.paginate():
+            instances = _flatten_db_instances(page)
+            for instance in instances:
+                endpoint_addr = _get_endpoint_address(instance)
+                endpoint_port = _get_endpoint_port(instance)
+
+                all_instances.append(
+                    {
+                        "dbInstanceIdentifier": instance["DBInstanceIdentifier"],
+                        "dbInstanceClass": instance.get("DBInstanceClass", ""),
+                        "engine": instance.get("Engine", ""),
+                        "engineVersion": instance.get("EngineVersion", ""),
+                        "status": instance.get("DBInstanceStatus", ""),
+                        "masterUsername": instance.get("MasterUsername", ""),
+                        "endpoint": endpoint_addr,
+                        "port": endpoint_port,
+                        "multiAz": instance.get("MultiAZ", False),
+                        "availabilityZone": instance.get("AvailabilityZone", ""),
+                        "storageType": instance.get("StorageType", ""),
+                        "allocatedStorage": instance.get("AllocatedStorage", 0),
+                        "storageEncrypted": instance.get("StorageEncrypted", False),
+                        "publiclyAccessible": instance.get("PubliclyAccessible", False),
+                        "vpcSecurityGroups": instance.get("VpcSecurityGroups", []),
+                        "dbSubnetGroup": instance.get("DBSubnetGroup", {}),
+                        "parameterGroup": instance.get("DBParameterGroups", [{}])[0] if instance.get("DBParameterGroups") else {},
+                        "tags": instance.get("TagList", []),
+                        "createdTime": instance.get("InstanceCreateTime"),
+                        "readReplicaSourceIdentifier": instance.get("ReadReplicaSourceDBInstanceIdentifier"),
+                        "readReplicaIdentifiers": instance.get("ReadReplicaDBInstanceIdentifiers", []),
+                    }
+                )
+
+        return {"instances": all_instances}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/instances/{instance_id}")
+def get_db_instance_detail(instance_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get detailed information for a specific DB instance."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+
+        response = client.describe_db_instances(DBInstanceIdentifier=instance_id)
+        instances = _flatten_db_instances(response)
+
+        if not instances:
+            raise HTTPException(status_code=404, detail=f"DB Instance {instance_id} not found")
+
+        instance = instances[0]
+        endpoint_addr = _get_endpoint_address(instance)
+        endpoint_port = _get_endpoint_port(instance)
+
+        # Get tags separately
+        try:
+            tags_response = client.list_tags_for_resource(ResourceName=instance.get("DbiResourceId", ""))
+            tags = tags_response.get("TagList", [])
+        except Exception:
+            tags = instance.get("TagList", [])
+
+        return {
+            "instance": {
+                "dbInstanceIdentifier": instance["DBInstanceIdentifier"],
+                "dbInstanceClass": instance.get("DBInstanceClass", ""),
+                "engine": instance.get("Engine", ""),
+                "engineVersion": instance.get("EngineVersion", ""),
+                "status": instance.get("DBInstanceStatus", ""),
+                "masterUsername": instance.get("MasterUsername", ""),
+                "endpoint": endpoint_addr,
+                "port": endpoint_port,
+                "multiAz": instance.get("MultiAZ", False),
+                "availabilityZone": instance.get("AvailabilityZone", ""),
+                "storageType": instance.get("StorageType", ""),
+                "allocatedStorage": instance.get("AllocatedStorage", 0),
+                "iops": instance.get("Iops"),
+                "storageEncrypted": instance.get("StorageEncrypted", False),
+                "kmsKeyId": instance.get("KmsKeyId"),
+                "publiclyAccessible": instance.get("PubliclyAccessible", False),
+                "vpcSecurityGroups": instance.get("VpcSecurityGroups", []),
+                "dbSubnetGroup": instance.get("DBSubnetGroup", {}),
+                "dbParameterGroups": instance.get("DBParameterGroups", []),
+                "optionGroupMemberships": instance.get("OptionGroupMemberships", []),
+                "tags": tags,
+                "createdTime": instance.get("InstanceCreateTime"),
+                "backupRetentionPeriod": instance.get("BackupRetentionPeriod", 0),
+                "preferredBackupWindow": instance.get("PreferredBackupWindow", ""),
+                "preferredMaintenanceWindow": instance.get("PreferredMaintenanceWindow", ""),
+                "readReplicaSourceIdentifier": instance.get("ReadReplicaSourceDBInstanceIdentifier"),
+                "readReplicaIdentifiers": instance.get("ReadReplicaDBInstanceIdentifiers", []),
+                "certificateDetails": instance.get("CertificateDetails", {}),
+                "pendingModifiedValues": instance.get("PendingModifiedValues", {}),
+                "latestRestorableTime": instance.get("LatestRestorableTime"),
+                "earliestRestorableTime": instance.get("EarliestRestorableTime"),
+            }
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        error_msg = str(e)
+        if "DBInstanceNotFound" in error_msg:
+            raise HTTPException(status_code=404, detail=f"DB Instance {instance_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/clusters")
+def list_db_clusters(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all RDS DB clusters with enriched metadata."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+        paginator = client.get_paginator("describe_db_clusters")
+
+        all_clusters = []
+        for page in paginator.paginate():
+            clusters = _flatten_db_clusters(page)
+            for cluster in clusters:
+                all_clusters.append(
+                    {
+                        "dbClusterIdentifier": cluster["DBClusterIdentifier"],
+                        "engine": cluster.get("Engine", ""),
+                        "engineVersion": cluster.get("EngineVersion", ""),
+                        "status": cluster.get("Status", ""),
+                        "masterUsername": cluster.get("MasterUsername", ""),
+                        "endpoint": cluster.get("Endpoint", ""),
+                        "readerEndpoint": cluster.get("ReaderEndpoint", ""),
+                        "port": cluster.get("Port", 0),
+                        "multiAz": cluster.get("MultiAZ", False),
+                        "storageType": cluster.get("StorageType", ""),
+                        "allocatedStorage": cluster.get("AllocatedStorage", 0),
+                        "storageEncrypted": cluster.get("StorageEncrypted", False),
+                        "vpcSecurityGroups": cluster.get("VpcSecurityGroups", []),
+                        "dbSubnetGroup": cluster.get("DBSubnetGroup", ""),
+                        "parameterGroup": cluster.get("DBClusterParameterGroup", ""),
+                        "tags": cluster.get("TagList", []),
+                        "createdTime": cluster.get("ClusterCreateTime"),
+                        "earliestRestorableTime": cluster.get("EarliestRestorableTime"),
+                        "latestRestorableTime": cluster.get("LatestRestorableTime"),
+                        "backupRetentionPeriod": cluster.get("BackupRetentionPeriod", 0),
+                        "preferredBackupWindow": cluster.get("PreferredBackupWindow", ""),
+                        "preferredMaintenanceWindow": cluster.get("PreferredMaintenanceWindow", ""),
+                        "readReplicaIdentifiers": cluster.get("ReadReplicaDBClusterIdentifiers", []),
+                        "dbClusterMembers": cluster.get("DBClusterMembers", []),
+                        "serverlessV2ScalingConfiguration": cluster.get("ServerlessV2ScalingConfiguration", {}),
+                    }
+                )
+
+        return {"clusters": all_clusters}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/clusters/{cluster_id}")
+def get_db_cluster_detail(cluster_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get detailed information for a specific DB cluster."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+
+        response = client.describe_db_clusters(DBClusterIdentifier=cluster_id)
+        clusters = _flatten_db_clusters(response)
+
+        if not clusters:
+            raise HTTPException(status_code=404, detail=f"DB Cluster {cluster_id} not found")
+
+        cluster = clusters[0]
+
+        # Get tags separately
+        try:
+            tags_response = client.list_tags_for_resource(ResourceName=cluster.get("DbClusterResourceId", ""))
+            tags = tags_response.get("TagList", [])
+        except Exception:
+            tags = cluster.get("TagList", [])
+
+        return {
+            "cluster": {
+                "dbClusterIdentifier": cluster["DBClusterIdentifier"],
+                "engine": cluster.get("Engine", ""),
+                "engineVersion": cluster.get("EngineVersion", ""),
+                "status": cluster.get("Status", ""),
+                "masterUsername": cluster.get("MasterUsername", ""),
+                "endpoint": cluster.get("Endpoint", ""),
+                "readerEndpoint": cluster.get("ReaderEndpoint", ""),
+                "port": cluster.get("Port", 0),
+                "multiAz": cluster.get("MultiAZ", False),
+                "storageType": cluster.get("StorageType", ""),
+                "allocatedStorage": cluster.get("AllocatedStorage", 0),
+                "storageEncrypted": cluster.get("StorageEncrypted", False),
+                "kmsKeyId": cluster.get("KmsKeyId"),
+                "vpcSecurityGroups": cluster.get("VpcSecurityGroups", []),
+                "dbSubnetGroup": cluster.get("DBSubnetGroup", ""),
+                "dbClusterParameterGroup": cluster.get("DBClusterParameterGroup", ""),
+                "optionGroupMemberships": cluster.get("OptionGroupMemberships", []),
+                "tags": tags,
+                "createdTime": cluster.get("ClusterCreateTime"),
+                "earliestRestorableTime": cluster.get("EarliestRestorableTime"),
+                "latestRestorableTime": cluster.get("LatestRestorableTime"),
+                "backupRetentionPeriod": cluster.get("BackupRetentionPeriod", 0),
+                "preferredBackupWindow": cluster.get("PreferredBackupWindow", ""),
+                "preferredMaintenanceWindow": cluster.get("PreferredMaintenanceWindow", ""),
+                "readReplicaIdentifiers": cluster.get("ReadReplicaDBClusterIdentifiers", []),
+                "dbClusterMembers": cluster.get("DBClusterMembers", []),
+                "serverlessV2ScalingConfiguration": cluster.get("ServerlessV2ScalingConfiguration", {}),
+                "scalingConfigurationInfo": cluster.get("ScalingConfigurationInfo", {}),
+                "pendingModifiedValues": cluster.get("PendingModifiedValues", {}),
+            }
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        error_msg = str(e)
+        if "DBClusterNotFound" in error_msg:
+            raise HTTPException(status_code=404, detail=f"DB Cluster {cluster_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/snapshots")
+def list_db_snapshots(
+    instance_id: str | None = Query(None, description="Filter by DB instance identifier"),
+    cluster_id: str | None = Query(None, description="Filter by DB cluster identifier"),
+    snapshot_type: str | None = Query(None, description="Filter by snapshot type (automated/manual)"),
+    ep: EndpointInfo = Depends(get_endpoint_info),
+) -> dict[str, Any]:
+    """List RDS DB snapshots with optional filters."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+
+        snapshots = []
+
+        if instance_id:
+            # Get snapshots for a specific instance
+            paginator = client.get_paginator("describe_db_snapshots")
+            for page in paginator.paginate(DBInstanceIdentifier=instance_id):
+                snapshots.extend(page.get("DBSnapshots", []))
+        elif cluster_id:
+            # Get cluster snapshots
+            paginator = client.get_paginator("describe_db_cluster_snapshots")
+            for page in paginator.paginate(DBClusterIdentifier=cluster_id):
+                snapshots.extend(page.get("DBClusterSnapshots", []))
+        elif snapshot_type:
+            # Get snapshots by type
+            paginator = client.get_paginator("describe_db_snapshots")
+            for page in paginator.paginate(SnapshotType=snapshot_type):
+                snapshots.extend(page.get("DBSnapshots", []))
+        else:
+            # Get all snapshots (instance snapshots)
+            paginator = client.get_paginator("describe_db_snapshots")
+            for page in paginator.paginate():
+                snapshots.extend(page.get("DBSnapshots", []))
+
+        result = []
+        for snapshot in snapshots:
+            # Handle both DBSnapshot and DBClusterSnapshot
+            is_cluster = "DBClusterSnapshotIdentifier" in snapshot
+            result.append(
+                {
+                    "snapshotIdentifier": snapshot.get("DBSnapshotIdentifier" if not is_cluster else "DBClusterSnapshotIdentifier", ""),
+                    "snapshotType": snapshot.get("SnapshotType", ""),
+                    "status": snapshot.get("Status", ""),
+                    "sourceType": "cluster" if is_cluster else "instance",
+                    "sourceIdentifier": snapshot.get("DBInstanceIdentifier" if not is_cluster else "DBClusterIdentifier", ""),
+                    "engine": snapshot.get("Engine", ""),
+                    "engineVersion": snapshot.get("EngineVersion", ""),
+                    "allocatedStorage": snapshot.get("AllocatedStorage", 0),
+                    "snapshotCreateTime": snapshot.get("SnapshotCreateTime"),
+                    "snapshotSize": snapshot.get("SnapshotSize", 0),
+                    "encrypted": snapshot.get("Encrypted", False),
+                    "kmsKeyId": snapshot.get("KmsKeyId"),
+                    "tags": snapshot.get("TagList", []),
+                }
+            )
+
+        return {"snapshots": result}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/parameter-groups")
+def list_db_parameter_groups(
+    source: str = Query("all", description="Source type: all, instance, or cluster"),
+    ep: EndpointInfo = Depends(get_endpoint_info),
+) -> dict[str, Any]:
+    """List RDS DB parameter groups."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+
+        parameter_groups = []
+
+        if source in ("all", "instance"):
+            # Get instance parameter groups
+            paginator = client.get_paginator("describe_db_parameter_groups")
+            for page in paginator.paginate():
+                for group in page.get("DBParameterGroups", []):
+                    parameter_groups.append(
+                        {
+                            "name": group.get("DBParameterGroupName", ""),
+                            "family": group.get("DBParameterGroupFamily", ""),
+                            "description": group.get("Description", ""),
+                            "source": "instance",
+                            "tags": group.get("TagList", []),
+                        }
+                    )
+
+        if source in ("all", "cluster"):
+            # Get cluster parameter groups
+            paginator = client.get_paginator("describe_db_cluster_parameter_groups")
+            for page in paginator.paginate():
+                for group in page.get("DBClusterParameterGroups", []):
+                    parameter_groups.append(
+                        {
+                            "name": group.get("DBClusterParameterGroupName", ""),
+                            "family": group.get("DBClusterParameterGroupFamily", ""),
+                            "description": group.get("Description", ""),
+                            "source": "cluster",
+                            "tags": group.get("TagList", []),
+                        }
+                    )
+
+        return {"parameterGroups": parameter_groups}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/parameter-groups/{group_name}")
+def get_db_parameter_group_detail(
+    group_name: str,
+    source: str = Query("instance", description="Source type: instance or cluster"),
+    ep: EndpointInfo = Depends(get_endpoint_info),
+) -> dict[str, Any]:
+    """Get detailed information for a specific parameter group including parameters."""
+    try:
+        client = get_client("rds", **ep.client_kwargs())
+
+        if source == "cluster":
+            # Get cluster parameter group details
+            response = client.describe_db_cluster_parameters(DBClusterParameterGroupName=group_name)
+            parameters = response.get("Parameters", [])
+
+            # Get group info
+            groups_response = client.describe_db_cluster_parameter_groups(DBClusterParameterGroupName=group_name)
+            groups = groups_response.get("DBClusterParameterGroups", [])
+            group_info = groups[0] if groups else {}
+
+            return {
+                "parameterGroup": {
+                    "name": group_info.get("DBClusterParameterGroupName", group_name),
+                    "family": group_info.get("DBClusterParameterGroupFamily", ""),
+                    "description": group_info.get("Description", ""),
+                    "source": "cluster",
+                    "parameters": [
+                        {
+                            "name": p.get("ParameterName", ""),
+                            "value": p.get("ParameterValue", ""),
+                            "description": p.get("Description", ""),
+                            "dataType": p.get("DataType", ""),
+                            "allowedValues": p.get("AllowedValues", ""),
+                            "isModifiable": p.get("IsModifiable", False),
+                            "applyMethod": p.get("ApplyMethod", "immediate"),
+                        }
+                        for p in parameters
+                    ],
+                }
+            }
+        else:
+            # Get instance parameter group details
+            response = client.describe_db_parameters(DBParameterGroupName=group_name)
+            parameters = response.get("Parameters", [])
+
+            # Get group info
+            groups_response = client.describe_db_parameter_groups(DBParameterGroupName=group_name)
+            groups = groups_response.get("DBParameterGroups", [])
+            group_info = groups[0] if groups else {}
+
+            return {
+                "parameterGroup": {
+                    "name": group_info.get("DBParameterGroupName", group_name),
+                    "family": group_info.get("DBParameterGroupFamily", ""),
+                    "description": group_info.get("Description", ""),
+                    "source": "instance",
+                    "parameters": [
+                        {
+                            "name": p.get("ParameterName", ""),
+                            "value": p.get("ParameterValue", ""),
+                            "description": p.get("Description", ""),
+                            "dataType": p.get("DataType", ""),
+                            "allowedValues": p.get("AllowedValues", ""),
+                            "isModifiable": p.get("IsModifiable", False),
+                            "applyMethod": p.get("ApplyMethod", "immediate"),
+                        }
+                        for p in parameters
+                    ],
+                }
+            }
+    except HTTPException:
+        raise
+    except Exception as e:
+        error_msg = str(e)
+        if "DBParameterGroupNotFound" in error_msg or "DBClusterParameterGroupNotFound" in error_msg:
+            raise HTTPException(status_code=404, detail=f"Parameter Group {group_name} not found")
+        raise HTTPException(status_code=500, detail=str(e))

{stackport-0.3.4 → stackport-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackport"
-version = "0.3.4"
+version = "0.3.6"
 description = "Universal AWS resource browser for local emulators"
 readme = "README.md"
 license = {text = "MIT"}
@@ -34,7 +34,7 @@ Repository = "https://github.com/DaviReisVieira/stackport"
 Issues = "https://github.com/DaviReisVieira/stackport/issues"
 
 [project.optional-dependencies]
-dev = ["pytest>=8.0", "httpx>=0.27.0", "moto[s3,sqs,lambda,dynamodb,iam]>=5.0"]
+dev = ["pytest>=8.0", "pytest-mock>=3.12.0", "httpx>=0.27.0", "moto[s3,sqs,lambda,dynamodb,iam]>=5.0"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{stackport-0.3.4 → stackport-0.3.6/stackport.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.3.4
+Version: 0.3.6
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT
@@ -29,6 +29,7 @@ Requires-Dist: websockets>=12.0
 Requires-Dist: python-multipart>=0.0.26
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
 Requires-Dist: httpx>=0.27.0; extra == "dev"
 Requires-Dist: moto[dynamodb,iam,lambda,s3,sqs]>=5.0; extra == "dev"
 Dynamic: license-file

{stackport-0.3.4 → stackport-0.3.6}/stackport.egg-info/SOURCES.txt

@@ -13,9 +13,9 @@ backend/websocket.py
 backend/../ui/dist/favicon.png
 backend/../ui/dist/favicon.svg
 backend/../ui/dist/index.html
-backend/../ui/dist/assets/StateMachineGraph-B8vy_SNe.js
+backend/../ui/dist/assets/StateMachineGraph-DnspmX4c.js
 backend/../ui/dist/assets/index-BoJK2una.css
-backend/../ui/dist/assets/index-DsnQ23fm.js
+backend/../ui/dist/assets/index-CVBAWnD3.js
 backend/../ui/dist/assets/stepfunctions-graph-B6nvU4OB.js
 backend/../ui/dist/aws-icons/acm.svg
 backend/../ui/dist/aws-icons/apigateway.svg
@@ -59,6 +59,7 @@ backend/routes/endpoints.py
 backend/routes/iam.py
 backend/routes/lambda_svc.py
 backend/routes/logs.py
+backend/routes/rds.py
 backend/routes/resources.py
 backend/routes/s3.py
 backend/routes/secretsmanager.py
@@ -93,6 +94,7 @@ tests/test_iam_routes.py
 tests/test_lambda_routes.py
 tests/test_logs_routes.py
 tests/test_multi_endpoint.py
+tests/test_rds_routes.py
 tests/test_readonly_middleware.py
 tests/test_registries.py
 tests/test_routes.py
@@ -105,9 +107,9 @@ tests/test_websocket.py
 ui/dist/favicon.png
 ui/dist/favicon.svg
 ui/dist/index.html
-ui/dist/assets/StateMachineGraph-B8vy_SNe.js
+ui/dist/assets/StateMachineGraph-DnspmX4c.js
 ui/dist/assets/index-BoJK2una.css
-ui/dist/assets/index-DsnQ23fm.js
+ui/dist/assets/index-CVBAWnD3.js
 ui/dist/assets/stepfunctions-graph-B6nvU4OB.js
 ui/dist/aws-icons/acm.svg
 ui/dist/aws-icons/apigateway.svg

{stackport-0.3.4 → stackport-0.3.6}/stackport.egg-info/requires.txt

@@ -7,5 +7,6 @@ python-multipart>=0.0.26
 
 [dev]
 pytest>=8.0
+pytest-mock>=3.12.0
 httpx>=0.27.0
 moto[dynamodb,iam,lambda,s3,sqs]>=5.0