@weirdfingers/baseboards 0.2.0

package/templates/api/src/boards/storage/implementations/s3.py

@@ -0,0 +1,294 @@
+"""AWS S3 storage provider with IAM auth and CloudFront CDN support."""
+
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import boto3
+
+try:
+    import aioboto3
+    import boto3
+    from botocore.config import Config
+    from botocore.exceptions import ClientError, NoCredentialsError
+
+    _s3_available = True
+except ImportError:
+    boto3 = None
+    ClientError = None
+    NoCredentialsError = None
+    Config = None
+    aioboto3 = None
+    _s3_available = False
+
+from ...logging import get_logger
+from ..base import StorageException, StorageProvider
+
+logger = get_logger(__name__)
+
+
+class S3StorageProvider(StorageProvider):
+    """AWS S3 storage with IAM auth, CloudFront CDN, and proper async patterns."""
+
+    def __init__(
+        self,
+        bucket: str,
+        region: str = "us-east-1",
+        aws_access_key_id: str | None = None,
+        aws_secret_access_key: str | None = None,
+        aws_session_token: str | None = None,
+        endpoint_url: str | None = None,
+        cloudfront_domain: str | None = None,
+        upload_config: dict[str, Any] | None = None,
+    ):
+        if not _s3_available:
+            raise ImportError("boto3 and aioboto3 are required for S3StorageProvider")
+
+        self.bucket = bucket
+        self.region = region
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.aws_session_token = aws_session_token
+        self.endpoint_url = endpoint_url
+        self.cloudfront_domain = cloudfront_domain
+
+        # Default upload configuration
+        self.upload_config = {
+            "ServerSideEncryption": "AES256",
+            "StorageClass": "STANDARD",
+            **(upload_config or {}),
+        }
+
+        # Configure boto3 with optimized settings
+        self.config = Config(  # type: ignore[reportUnknownMemberType]
+            region_name=self.region,
+            retries={"max_attempts": 3, "mode": "adaptive"},
+            max_pool_connections=50,
+        )
+
+        self._session: Any | None = None
+
+    def _get_session(self) -> Any:
+        """Get or create the aioboto3 session."""
+        if self._session is None:
+            self._session = aioboto3.Session(  # type: ignore[reportUnknownMemberType]
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+                aws_session_token=self.aws_session_token,
+                region_name=self.region,
+            )
+        return self._session
+
+    async def upload(
+        self,
+        key: str,
+        content: bytes | AsyncIterator[bytes],
+        content_type: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> str:
+        """Upload content to S3."""
+        try:
+            session = self._get_session()
+
+            # Prepare upload parameters
+            upload_params = {
+                "Bucket": self.bucket,
+                "Key": key,
+                "ContentType": content_type,
+                **self.upload_config,
+            }
+
+            # Add custom metadata (S3 requires x-amz-meta- prefix)
+            if metadata:
+                s3_metadata = {}
+                for k, v in metadata.items():
+                    # Convert values to strings and sanitize keys
+                    clean_key = k.replace("-", "_").replace(" ", "_")
+                    s3_metadata[clean_key] = str(v)
+                upload_params["Metadata"] = s3_metadata
+
+            # Handle streaming content for large files
+            if isinstance(content, bytes):
+                upload_params["Body"] = content
+            else:
+                # Collect streaming content into memory for upload
+                # For very large files, consider using S3 multipart upload
+                chunks = []
+                total_size = 0
+                async for chunk in content:
+                    chunks.append(chunk)
+                    total_size += len(chunk)
+                    # For files larger than 100MB, we could implement multipart upload
+                    if total_size > 100 * 1024 * 1024:
+                        logger.warning(
+                            f"Large file upload ({total_size} bytes) - "
+                            f"consider implementing multipart upload for key: {key}"
+                        )
+
+                upload_params["Body"] = b"".join(chunks)
+
+            # Upload using aioboto3
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                await s3.put_object(**upload_params)
+
+            # Return the CloudFront URL if configured, otherwise S3 URL
+            if self.cloudfront_domain:
+                return f"https://{self.cloudfront_domain}/{key}"
+            else:
+                return f"https://{self.bucket}.s3.{self.region}.amazonaws.com/{key}"
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Unexpected error uploading {key} to S3: {e}")
+            raise StorageException(f"S3 upload failed: {e}") from e
+
+    async def download(self, key: str) -> bytes:
+        """Download file content from S3."""
+        try:
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                response = await s3.get_object(Bucket=self.bucket, Key=key)
+
+                # Read the streaming body
+                content = await response["Body"].read()
+                return content
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to download {key} from S3: {e}")
+            raise StorageException(f"S3 download failed: {e}") from e
+
+    async def get_presigned_upload_url(
+        self,
+        key: str,
+        content_type: str,
+        expires_in: timedelta | None = None,
+    ) -> dict[str, Any]:
+        """Generate presigned URL for direct client uploads."""
+        if expires_in is None:
+            expires_in = timedelta(hours=1)
+
+        try:
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                # Generate presigned POST for direct uploads with form fields
+                response = await s3.generate_presigned_post(
+                    Bucket=self.bucket,
+                    Key=key,
+                    Fields={"Content-Type": content_type, **self.upload_config},
+                    Conditions=[
+                        {"Content-Type": content_type},
+                        [
+                            "content-length-range",
+                            1,
+                            self.upload_config.get("max_file_size", 100 * 1024 * 1024),
+                        ],
+                    ],
+                    ExpiresIn=int(expires_in.total_seconds()),
+                )
+
+                return {
+                    "url": response["url"],
+                    "fields": response["fields"],
+                    "expires_at": (datetime.now(UTC) + expires_in).isoformat(),
+                }
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to create presigned upload URL for {key}: {e}")
+            raise StorageException(f"S3 presigned URL creation failed: {e}") from e
+
+    async def get_presigned_download_url(
+        self, key: str, expires_in: timedelta | None = None
+    ) -> str:
+        """Generate presigned URL for secure downloads."""
+        if expires_in is None:
+            expires_in = timedelta(hours=1)
+
+        try:
+            # Always use S3 native presigned URLs for security
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                url = await s3.generate_presigned_url(
+                    "get_object",
+                    Params={"Bucket": self.bucket, "Key": key},
+                    ExpiresIn=int(expires_in.total_seconds()),
+                )
+                return url
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to create presigned download URL for {key}: {e}")
+            raise StorageException(f"S3 presigned download URL creation failed: {e}") from e
+
+    async def delete(self, key: str) -> bool:
+        """Delete file by storage key."""
+        try:
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                await s3.delete_object(Bucket=self.bucket, Key=key)
+                return True
+
+        except Exception as e:
+            logger.error(f"Unexpected error deleting {key} from S3: {e}")
+            raise StorageException(f"S3 delete failed: {e}") from e
+
+    async def exists(self, key: str) -> bool:
+        """Check if file exists."""
+        try:
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                await s3.head_object(Bucket=self.bucket, Key=key)
+                return True
+        except Exception:
+            return False
+
+    async def get_metadata(self, key: str) -> dict[str, Any]:
+        """Get file metadata (size, modified date, etc.)."""
+        try:
+            session = self._get_session()
+            async with session.client(
+                "s3", config=self.config, endpoint_url=self.endpoint_url
+            ) as s3:
+                response = await s3.head_object(Bucket=self.bucket, Key=key)
+
+                # Extract metadata
+                result = {
+                    "size": response.get("ContentLength", 0),
+                    "last_modified": response.get("LastModified"),
+                    "content_type": response.get("ContentType"),
+                    "etag": response.get("ETag", "").strip('"'),
+                    "version_id": response.get("VersionId"),
+                    "storage_class": response.get("StorageClass", "STANDARD"),
+                    "server_side_encryption": response.get("ServerSideEncryption"),
+                }
+
+                # Add custom metadata (remove x-amz-meta- prefix)
+                custom_metadata = response.get("Metadata", {})
+                if custom_metadata:
+                    result["custom_metadata"] = custom_metadata
+
+                return result
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to get metadata for {key} from S3: {e}")
+            raise StorageException(f"S3 get metadata failed: {e}") from e

package/templates/api/src/boards/storage/implementations/supabase.py

@@ -0,0 +1,218 @@
+"""Supabase storage provider with integrated auth and CDN support."""
+
+import os
+import tempfile
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING, Any
+
+import aiofiles
+
+if TYPE_CHECKING:
+    from supabase import AsyncClient, create_async_client
+
+try:
+    from supabase import AsyncClient, create_async_client
+
+    _supabase_available = True
+except ImportError:
+    # Handle case where supabase is not installed
+    create_async_client = None
+    # AsyncClient = None
+    _supabase_available = False
+
+from ...logging import get_logger
+from ..base import StorageException, StorageProvider
+
+logger = get_logger(__name__)
+
+
+class SupabaseStorageProvider(StorageProvider):
+    """Supabase storage with integrated auth, CDN, and proper async patterns."""
+
+    def __init__(self, url: str, key: str, bucket: str):
+        if not _supabase_available:
+            raise ImportError("supabase-py is required for SupabaseStorageProvider")
+
+        self.url = url
+        self.key = key
+        self.bucket = bucket
+        self._client: AsyncClient | None = None
+
+    async def _get_client(self) -> "AsyncClient":
+        """Get or create the async Supabase client."""
+        if self._client is None:
+            if create_async_client is None:
+                raise ImportError("Async Supabase client not available")
+            self._client = await create_async_client(self.url, self.key)
+        return self._client
+
+    async def upload(
+        self,
+        key: str,
+        content: bytes | AsyncIterator[bytes],
+        content_type: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> str:
+        try:
+            client = await self._get_client()
+
+            # Handle streaming content for large files
+            if isinstance(content, bytes):
+                file_content = content
+            else:
+                # Stream to temp file to avoid memory issues
+                with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+                    tmp_file_path = tmp_file.name
+
+                # Use async file operations for streaming content
+                async with aiofiles.open(tmp_file_path, "wb") as f:
+                    async for chunk in content:
+                        await f.write(chunk)
+
+                # Read the temp file asynchronously and upload
+                async with aiofiles.open(tmp_file_path, "rb") as f:
+                    file_content = await f.read()
+
+                # Clean up temp file
+                os.unlink(tmp_file_path)
+
+            # Use async Supabase client methods
+            response = await client.storage.from_(self.bucket).upload(
+                path=key,
+                file=file_content,
+                file_options={
+                    "content-type": content_type,
+                    "upsert": "false",  # Prevent accidental overwrites
+                },
+            )
+
+            return response.path
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Unexpected error uploading {key} to Supabase: {e}")
+            raise StorageException(f"Supabase upload failed: {e}") from e
+
+    async def download(self, key: str) -> bytes:
+        """Download file content from Supabase storage."""
+        try:
+            client = await self._get_client()
+            response = await client.storage.from_(self.bucket).download(key)
+
+            return response
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to download {key} from Supabase: {e}")
+            raise StorageException(f"Download failed: {e}") from e
+
+    async def get_presigned_upload_url(
+        self,
+        key: str,
+        content_type: str,
+        expires_in: timedelta | None = None,
+    ) -> dict[str, Any]:
+        """Generate presigned URL for direct client uploads."""
+        if expires_in is None:
+            expires_in = timedelta(hours=1)
+
+        try:
+            client = await self._get_client()
+            response = await client.storage.from_(self.bucket).create_signed_upload_url(path=key)
+
+            return {
+                "url": response["signed_url"],
+                "fields": {},  # Supabase doesn't use form fields like S3
+                "expires_at": (datetime.now(UTC) + expires_in).isoformat(),
+            }
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to create presigned upload URL for {key}: {e}")
+            raise StorageException(f"Presigned URL creation failed: {e}") from e
+
+    async def get_presigned_download_url(
+        self, key: str, expires_in: timedelta | None = None
+    ) -> str:
+        """Generate presigned URL for secure downloads."""
+        if expires_in is None:
+            expires_in = timedelta(hours=1)
+
+        try:
+            client = await self._get_client()
+            response = await client.storage.from_(self.bucket).create_signed_url(
+                path=key, expires_in=int(expires_in.total_seconds())
+            )
+
+            return response["signedURL"]
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to create presigned download URL for {key}: {e}")
+            raise StorageException(f"Presigned download URL creation failed: {e}") from e
+
+    async def delete(self, key: str) -> bool:
+        """Delete file by storage key."""
+        try:
+            client = await self._get_client()
+            await client.storage.from_(self.bucket).remove([key])  # type: ignore[reportUnknownMemberType]
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Unexpected error deleting {key} from Supabase: {e}")
+            raise StorageException(f"Delete failed: {e}") from e
+
+    async def exists(self, key: str) -> bool:
+        """Check if file exists."""
+        try:
+            client = await self._get_client()
+            # Try to get file info - if it doesn't exist, this will error
+            await client.storage.from_(self.bucket).get_public_url(key)
+            # If we get here without error, the file exists
+            return True
+        except Exception:
+            # Any error means the file doesn't exist or we can't access it
+            return False
+
+    async def get_metadata(self, key: str) -> dict[str, Any]:
+        """Get file metadata (size, modified date, etc.)."""
+        try:
+            client = await self._get_client()
+            # Supabase doesn't have a direct metadata endpoint
+            # We'll need to use the list method with a prefix
+            response = await client.storage.from_(self.bucket).list(
+                path="/".join(key.split("/")[:-1]) or "/"
+            )
+
+            # Find our file in the results
+            file_info = None
+            filename = key.split("/")[-1]
+            for item in response:
+                if item.get("name") == filename:
+                    file_info = item
+                    break
+
+            if not file_info:
+                raise StorageException(f"File not found: {key}")
+
+            metadata = file_info.get("metadata", {})
+            result = {
+                "size": file_info.get("size", 0),
+                "last_modified": file_info.get("updated_at"),
+                "content_type": file_info.get("mimetype"),
+                "etag": file_info.get("id"),
+            }
+            if isinstance(metadata, dict):
+                result.update(metadata)
+            return result
+
+        except Exception as e:
+            if isinstance(e, StorageException):
+                raise
+            logger.error(f"Failed to get metadata for {key} from Supabase: {e}")
+            raise StorageException(f"Get metadata failed: {e}") from e