@weirdfingers/baseboards 0.9.5 → 0.9.7

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

@@ -1,201 +0,0 @@
-"""Local filesystem storage provider for development and self-hosted deployments."""
-
-import json
-from collections.abc import AsyncIterable
-from datetime import timedelta
-from pathlib import Path
-from typing import Any
-from urllib.parse import quote
-
-import aiofiles
-
-from ...logging import get_logger
-from ..base import SecurityException, StorageException, StorageProvider
-
-logger = get_logger(__name__)
-
-
-class LocalStorageProvider(StorageProvider):
-    """Local filesystem storage for development and self-hosted with security."""
-
-    def __init__(self, base_path: Path, public_url_base: str | None = None):
-        self.base_path = Path(base_path).resolve()  # Resolve to absolute path
-        self.public_url_base = public_url_base
-        self.base_path.mkdir(parents=True, exist_ok=True)
-
-    def _get_safe_file_path(self, key: str) -> Path:
-        """Get file path with security validation."""
-        # Ensure the resolved path is within base_path
-        file_path = (self.base_path / key).resolve()
-
-        # Check that resolved path is within base directory
-        try:
-            file_path.relative_to(self.base_path)
-        except ValueError as e:
-            raise SecurityException(f"Path traversal detected: {key}") from e
-
-        return file_path
-
-    async def upload(
-        self,
-        key: str,
-        content: bytes | bytearray | memoryview | AsyncIterable[bytes],
-        content_type: str,
-        metadata: dict[str, Any] | None = None,
-    ) -> str:
-        logger.info("Uploading file", key=key, content_type=content_type, metadata=metadata)
-        try:
-            file_path = self._get_safe_file_path(key)
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-
-            # Handle both bytes-like and async iterable content
-            if isinstance(content, bytes | bytearray | memoryview):
-                # aiofiles accepts bytes-like objects directly
-                async with aiofiles.open(file_path, "wb") as f:
-                    await f.write(content)
-            else:  # isinstance(content, AsyncIterable):
-                async with aiofiles.open(file_path, "wb") as f:
-                    async for chunk in content:
-                        # Just write the chunk directly - aiofiles accepts bytes-like objects
-                        # It will raise an error if chunk is not bytes-like
-                        await f.write(chunk)
-
-            # Store metadata atomically
-            if metadata:
-                try:
-                    metadata_path = file_path.with_suffix(file_path.suffix + ".meta")
-                    metadata_json = json.dumps(metadata, indent=2)
-
-                    async with aiofiles.open(metadata_path, "w") as f:
-                        await f.write(metadata_json)
-                except Exception as e:
-                    logger.warning(f"Failed to write metadata for {key}: {e}")
-                    # Continue - metadata failure shouldn't fail the upload
-
-            logger.debug(f"Successfully uploaded {key} to local storage")
-            return self._get_public_url(key)
-
-        except OSError as e:
-            logger.error(f"File system error uploading {key}: {e}")
-            raise StorageException(f"Failed to write file: {e}") from e
-        except Exception as e:
-            logger.error(f"Unexpected error uploading {key}: {e}")
-            raise StorageException(f"Upload failed: {e}") from e
-
-    def _get_public_url(self, key: str) -> str:
-        """Generate public URL for the stored file."""
-        if self.public_url_base:
-            # URL-encode the key for safety
-            encoded_key = quote(key, safe="/")
-            return f"{self.public_url_base.rstrip('/')}/{encoded_key}"
-        else:
-            return f"file://{self.base_path / key}"
-
-    async def download(self, key: str) -> bytes:
-        """Download file content from local storage."""
-        try:
-            file_path = self._get_safe_file_path(key)
-
-            if not file_path.exists():
-                raise StorageException(f"File not found: {key}")
-
-            async with aiofiles.open(file_path, "rb") as f:
-                return await f.read()
-
-        except OSError as e:
-            logger.error(f"File system error downloading {key}: {e}")
-            raise StorageException(f"Failed to read file: {e}") from e
-        except Exception as e:
-            logger.error(f"Unexpected error downloading {key}: {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]:
-        """Local storage doesn't support presigned URLs - return direct upload info."""
-        # For local storage, we can't really do presigned URLs
-        # This would be handled by the web server (e.g., FastAPI endpoint)
-        return {
-            "url": f"/api/storage/upload/{quote(key, safe='/')}",
-            "fields": {"content-type": content_type},
-            "method": "PUT",
-            "expires_at": None,  # Handled by server session
-        }
-
-    async def get_presigned_download_url(
-        self, key: str, expires_in: timedelta | None = None
-    ) -> str:
-        """Return the public URL for local storage."""
-        return self._get_public_url(key)
-
-    async def delete(self, key: str) -> bool:
-        """Delete file by storage key."""
-        try:
-            file_path = self._get_safe_file_path(key)
-
-            if not file_path.exists():
-                return False
-
-            # Delete the main file
-            file_path.unlink()
-
-            # Delete metadata file if it exists
-            metadata_path = file_path.with_suffix(file_path.suffix + ".meta")
-            if metadata_path.exists():
-                metadata_path.unlink()
-
-            logger.debug(f"Successfully deleted {key} from local storage")
-            return True
-
-        except OSError as e:
-            logger.error(f"File system error deleting {key}: {e}")
-            raise StorageException(f"Failed to delete file: {e}") from e
-        except Exception as e:
-            logger.error(f"Unexpected error deleting {key}: {e}")
-            raise StorageException(f"Delete failed: {e}") from e
-
-    async def exists(self, key: str) -> bool:
-        """Check if file exists."""
-        try:
-            file_path = self._get_safe_file_path(key)
-            return file_path.exists()
-        except SecurityException:
-            return False
-        except Exception as e:
-            logger.warning(f"Error checking existence of {key}: {e}")
-            return False
-
-    async def get_metadata(self, key: str) -> dict[str, Any]:
-        """Get file metadata (size, modified date, etc.)."""
-        try:
-            file_path = self._get_safe_file_path(key)
-
-            if not file_path.exists():
-                raise StorageException(f"File not found: {key}")
-
-            stat = file_path.stat()
-
-            # Try to load stored metadata
-            stored_metadata = {}
-            metadata_path = file_path.with_suffix(file_path.suffix + ".meta")
-            if metadata_path.exists():
-                try:
-                    async with aiofiles.open(metadata_path) as f:
-                        metadata_content = await f.read()
-                        stored_metadata = json.loads(metadata_content)
-                except Exception as e:
-                    logger.warning(f"Failed to load metadata for {key}: {e}")
-
-            return {
-                "size": stat.st_size,
-                "modified_time": stat.st_mtime,
-                "created_time": stat.st_ctime,
-                **stored_metadata,
-            }
-
-        except OSError as e:
-            logger.error(f"File system error getting metadata for {key}: {e}")
-            raise StorageException(f"Failed to get metadata: {e}") from e
-        except Exception as e:
-            logger.error(f"Unexpected error getting metadata for {key}: {e}")
-            raise StorageException(f"Get metadata failed: {e}") from e

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

@@ -1,294 +0,0 @@
-"""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