n8n-fixes

app.py

@@ -76,71 +76,14 @@ app = FastAPI(
     3. **Check status**: Monitor progress with `/jobs/{job_id}`
     4. **Download result**: Get extracted audio with `/jobs/{job_id}/download`
     5. **Optional trimming**: Use `start` and `end` parameters to download specific segments
-    
-    ### Authentication
-    Most endpoints require JWT Bearer token authentication. Include your token in the Authorization header:
-    ```
-    Authorization: Bearer <your-jwt-token>
-    ```
-    
-    Public endpoints (no authentication required):
-    - `GET /api/v1/info` - API information
-    - `GET /api/v1/health` - Health check
     """,
     version=settings.app_version,
     docs_url="/docs",
     redoc_url="/redoc",
     openapi_url="/openapi.json",
-    lifespan=lifespan,
-    # Add OpenAPI security scheme for Bearer token authentication
-    openapi_tags=[
-        {
-            "name": "extraction",
-            "description": "Audio extraction operations (requires authentication)"
-        },
-        {
-            "name": "jobs", 
-            "description": "Job management operations (requires authentication)"
-        },
-        {
-            "name": "info",
-            "description": "Public API information (no authentication required)"
-        }
-    ]
+    lifespan=lifespan
 )
 
-# Configure OpenAPI security scheme
-def custom_openapi():
-    if app.openapi_schema:
-        return app.openapi_schema
-    
-    from fastapi.openapi.utils import get_openapi
-    
-    openapi_schema = get_openapi(
-        title=app.title,
-        version=app.version,
-        description=app.description,
-        routes=app.routes,
-    )
-    
-    # Add Bearer token security scheme
-    openapi_schema["components"]["securitySchemes"] = {
-        "BearerAuth": {
-            "type": "http",
-            "scheme": "bearer",
-            "bearerFormat": "JWT",
-            "description": "JWT Bearer token authentication"
-        }
-    }
-    
-    app.openapi_schema = openapi_schema
-    return app.openapi_schema
-
-app.openapi = custom_openapi
-
-# Let FastAPI handle OpenAPI generation automatically
-# The HTTPBearer scheme in dependencies.py will be automatically detected
-
 # Configure middleware
 configure_cors(app)
 register_exception_handlers(app)

application/dto/extraction_response.py

@@ -16,10 +16,10 @@ class DirectExtractionResultDTO:
 class JobStatusDTO:
     """DTO for job status."""
     job_id: str
+    external_job_id: Optional[str] = None
     status: str
     created_at: datetime
     updated_at: datetime
-    external_job_id: Optional[str] = None
     filename: Optional[str] = None
     file_size_mb: Optional[float] = None
     output_format: Optional[str] = None
@@ -35,14 +35,14 @@ class DownloadResultDTO:
     media_type: str
     filename: str
     processing_time: float
-    storage_key: Optional[str] = None
+    storage_key: str = None
 
 @dataclass
 class JobCreationDTO:
     """DTO for job creation."""
     job_id: str
+    external_job_id: Optional[str] = None
     status: str
     message: str
     check_url: str
-    external_job_id: Optional[str] = None
     file_size_mb: Optional[float] = None

application/use_cases/process_job.py

@@ -88,25 +88,18 @@ class ProcessJobUseCase:
                 processing_time=processing_time
             )
 
-            # Send notification if service is available and we have a bearer token
-            if self.notification_service:
-                # Get job record to retrieve bearer token and external job ID
-                job_record = await self.job_repository.get(job_id)
-                bearer_token = job_record.bearer_token if job_record else None
-                external_job_id = job_record.external_job_id if job_record else None
-                
-                if bearer_token:
-                    await self.notification_service.send_job_completion_notification(
-                        job_id=job_id,
-                        status="completed",
-                        processing_time=processing_time,
-                        bearer_token=bearer_token,
-                        external_job_id=external_job_id
-                    )
-                else:
-                    logger.debug(f"Skipping N8N notification for job {job_id} - no bearer token available")
+            # Get job record to retrieve bearer token
+            job_record = await self.job_repository.get(job_id)
+            bearer_token = job_record.bearer_token if job_record else None
+
+            await self.notification_service.send_job_completion_notification(
+                job_id=job_id,
+                status="completed",
+                processing_time=processing_time,
+                bearer_token=bearer_token
+            )
             
-            # Clear bearer token for security (regardless of notification status)
+            # Clear bearer token for security after notification is sent
             await self.job_repository.clear_bearer_token(job_id)
             
             logger.info(f"Job {job_id} completed in {processing_time:.2f} seconds")
@@ -122,32 +115,29 @@ class ProcessJobUseCase:
                 processing_time=processing_time
             )
             
-            # Send failure notification if service is available and we have a bearer token
-            if self.notification_service:
-                try:
-                    job_record = await self.job_repository.get(job_id)
-                    bearer_token = job_record.bearer_token if job_record else None
-                    external_job_id = job_record.external_job_id if job_record else None
-                    
-                    if bearer_token:
-                        await self.notification_service.send_job_completion_notification(
-                            job_id=job_id,
-                            status="failed",
-                            processing_time=processing_time,
-                            bearer_token=bearer_token,
-                            external_job_id=external_job_id
-                        )
-                    else:
-                        logger.debug(f"Skipping N8N failure notification for job {job_id} - no bearer token available")
-                    
-                except Exception as notify_error:
-                    # Don't let notification failures mask the original job failure
-                    logger.warning(f"Failed to send failure notification for job {job_id}: {notify_error}")
-            
-            # Clear bearer token for security (regardless of notification status)
+            # Get job record to retrieve bearer token for failure notification
             try:
+                job_record = await self.job_repository.get(job_id)
+                bearer_token = job_record.bearer_token if job_record else None
+                
+                await self.notification_service.send_job_completion_notification(
+                    job_id=job_id,
+                    status="failed",
+                    processing_time=processing_time,
+                    bearer_token=bearer_token
+                )
+                
+                # Clear bearer token for security after notification is sent
                 await self.job_repository.clear_bearer_token(job_id)
-            except Exception:
-                logger.warning(f"Failed to clear bearer token for failed job {job_id}")
+                
+            except Exception as notify_error:
+                # Don't let notification failures mask the original job failure
+                logger.warning(f"Failed to send failure notification for job {job_id}: {notify_error}")
+                
+                # Still clear the token even if notification failed
+                try:
+                    await self.job_repository.clear_bearer_token(job_id)
+                except Exception:
+                    logger.warning(f"Failed to clear bearer token for failed job {job_id}")
             
             raise

domain/services/notification_service.py

@@ -17,6 +17,5 @@ class NotificationService(Protocol):
                                              job_id: str, 
                                              status: str,
                                              processing_time: float,
-                                             bearer_token: str,
-                                             external_job_id: Optional[str] = None) -> NotificationResponse:
+                                             bearer_token: Optional[str] = None) -> NotificationResponse:
         ...

infrastructure/clients/n8n/models.py

@@ -18,6 +18,6 @@ class WebhooksResponse:
 class N8NClientProtocol(Protocol):
     """Protocol defining the API client interface."""
     
-    async def post_completion_event(self, data: WebhooksRequest, bearer_token: str, external_job_id: Optional[str] = None) -> WebhooksResponse:
-        """Post to webhooks endpoint with client bearer token for authentication."""
+    async def post_completion_event(self, data: WebhooksRequest, bearer_token: Optional[str] = None) -> WebhooksResponse:
+        """Post to webhooks endpoint with optional client bearer token."""
         ...

infrastructure/clients/n8n/n8n_client.py

@@ -21,8 +21,9 @@ class N8NClient(N8NClientProtocol):
         )
     
     def _get_default_headers(self) -> Dict[str, str]:
-        """Get default headers (no authentication - client token will be provided per request)."""
+        """Get default headers including authentication."""
         return {
+            "Authorization": f"Bearer {self.settings.token}",
             "Content-Type": "application/json",
             "Accept": "application/json"
         }
@@ -87,26 +88,19 @@ class N8NClient(N8NClientProtocol):
             self.logger.error(f"Failed to parse JSON response from {url}: {str(e)}")
             raise APIResponseError(f"Invalid JSON response: {str(e)}", response.status_code)
     
-    async def post_completion_event(self, data: WebhooksRequest, bearer_token: str, external_job_id: Optional[str] = None) -> WebhooksResponse:
-        """Post to webhooks endpoint with client bearer token for authentication."""
+    async def post_completion_event(self, data: WebhooksRequest, bearer_token: Optional[str] = None) -> WebhooksResponse:
+        """Post to webhooks endpoint with optional client bearer token."""
         from dataclasses import asdict
         payload = asdict(data)
         
         # Extract job_id for header and remove from payload
         job_id = payload.pop("job_id")
+        custom_headers = {"rowID": job_id}
         
-        # Client bearer token is required for authentication to N8N
-        custom_headers = {
-            "rowID": job_id,
-            "Authorization": f"Bearer {bearer_token}"
-        }
-        
-        # Add external job ID as custom header if provided
-        if external_job_id:
-            custom_headers["externalJobID"] = external_job_id
-            self.logger.debug(f"Sending N8N notification for job {job_id} with external job ID {external_job_id}")
-        else:
-            self.logger.debug(f"Sending N8N notification for job {job_id} using client bearer token")
+        # Add client bearer token if provided
+        if bearer_token:
+            custom_headers["Authorization"] = f"Bearer {bearer_token}"
+            self.logger.debug(f"Adding client bearer token to N8N request for job {job_id}")
         
         response_data = await self._make_request("POST", "/lovable-analysis", payload, custom_headers)
         

infrastructure/clients/n8n/settings.py

@@ -6,4 +6,5 @@ from typing import Optional
 class ClientSettings:
     """Settings for the HTTP client."""
     base_url: str
+    token: str
     timeout: Optional[int] = 30

infrastructure/config/settings.py

@@ -88,8 +88,8 @@ class Settings(BaseSettings):
 
     # N8N Configuration
     n8n_base_url: str = Field(default="http://localhost:5678", env="N8N_BASE_URL")
+    n8n_token: str = Field(env="N8N_TOKEN")
     n8n_timeout: int = Field(default=30, env="N8N_TIMEOUT")
-    n8n_enabled: bool = Field(default=True, env="N8N_ENABLED")
     
     # Authentication Configuration
     enforce_authentication: bool = Field(default=True, env="ENFORCE_AUTHENTICATION")

infrastructure/services/container.py

@@ -61,16 +61,12 @@ class ServiceContainer:
         else:
             raise ValueError(f"Unsupported storage type: {settings.storage_type}")
     
-    def _create_notification_service(self) -> Optional[N8NNotificationService]:
-        """Create N8N notification service if enabled."""
-        # Check if N8N is enabled
-        if not settings.n8n_enabled:
-            logging.getLogger(__name__).info("N8N notifications disabled via configuration")
-            return None
-        
-        # Create N8N client settings (no token needed - client tokens are passed per request)
+    def _create_notification_service(self) -> N8NNotificationService:
+        """Create N8N notification service."""
+        # Create N8N client settings
         n8n_settings = ClientSettings(
             base_url=settings.n8n_base_url,
+            token=settings.n8n_token,
             timeout=getattr(settings, 'n8n_timeout', 30)
         )
         
@@ -97,10 +93,8 @@ class ServiceContainer:
     async def shutdown(self):
         """Cleanup services on shutdown."""
         await self.cleanup_service.stop()
-        # Close N8N client if it exists and has async cleanup
-        if (self.notification_service and 
-            hasattr(self.notification_service, 'n8n_client') and
-            hasattr(self.notification_service.n8n_client, 'close')):
+        # Close N8N client if it has async cleanup
+        if hasattr(self.notification_service.n8n_client, 'close'):
             await self.notification_service.n8n_client.close()
 
 # Convenience function for getting services

infrastructure/services/n8n_notification_service.py

@@ -25,17 +25,19 @@ class N8NNotificationService(NotificationService):
                                              job_id: str, 
                                              status: str,
                                              processing_time: float,
-                                             bearer_token: str,
-                                             external_job_id: Optional[str] = None) -> NotificationResponse:
-        """Send job completion notification via N8N with client bearer token for authentication."""
+                                             bearer_token: Optional[str] = None) -> NotificationResponse:
+        """Send job completion notification via N8N with optional client bearer token."""
         try:
             message = f"Job {job_id} {status} in {processing_time:.2f}s"
             request = NotificationRequest(message=message, job_id=job_id)
             
-            # Pass client bearer token and external job ID to N8N client
-            response = await self.n8n_client.post_completion_event(request, bearer_token, external_job_id)
+            # Pass bearer token to N8N client if provided
+            response = await self.n8n_client.post_completion_event(request, bearer_token)
             
-            logger.debug(f"Sent N8N notification for job {job_id} using client bearer token")
+            if bearer_token:
+                logger.debug(f"Sent N8N notification for job {job_id} with client bearer token")
+            else:
+                logger.debug(f"Sent N8N notification for job {job_id} without client bearer token")
                 
             return NotificationResponse(acknowledged=response.acknowledged)
             

interfaces/api/dependencies.py

@@ -1,7 +1,7 @@
+# interfaces/api/dependencies.py
 """FastAPI dependency injection configuration."""
 from typing import Annotated, Optional
 from fastapi import Depends, UploadFile, Form, HTTPException, Request, Header
-from fastapi.security import HTTPBearer
 from pydantic import BaseModel, Field, validator
 import re
 
@@ -9,13 +9,6 @@ from application.use_cases.container import UseCaseContainer
 from infrastructure.services.container import ServiceContainer
 from infrastructure.services.jwt_validation_service import JWTValidationService
 
-# Create HTTPBearer scheme that will be recognized by OpenAPI
-bearer_scheme = HTTPBearer(
-    scheme_name="BearerAuth",
-    bearerFormat="JWT",
-    description="JWT Bearer token authentication"
-)
-
 class ExtractionRequest(BaseModel):
     """Request model for audio extraction."""
     output_format: str = Field(default="mp3", description="Output audio format")
@@ -63,14 +56,14 @@ async def validate_video_file(video: UploadFile) -> UploadFile:
     
     return video
 
-async def get_validated_token(
-    credentials = Depends(bearer_scheme)
+async def validate_bearer_token(
+    authorization: Optional[str] = Header(None, description="Bearer token for authentication")
 ) -> str:
     """
-    Extract and validate bearer token from HTTPBearer scheme.
+    Extract and validate bearer token from Authorization header.
     
     Args:
-        credentials: HTTPAuthorizationCredentials from HTTPBearer scheme
+        authorization: Authorization header value
         
     Returns:
         str: The validated bearer token
@@ -78,20 +71,23 @@ async def get_validated_token(
     Raises:
         HTTPException: 401 if token is missing or invalid
     """
-    from infrastructure.config.settings import settings
-
-    if not settings.enforce_authentication:
-        return "authentication-disabled"
-    
-    if not credentials:
+    if not authorization:
         raise HTTPException(
             status_code=401,
             detail="Missing Authorization header",
             headers={"WWW-Authenticate": "Bearer"}
         )
     
-    # Extract token from credentials
-    token = credentials.credentials
+    # Check if it starts with "Bearer "
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid Authorization header format. Expected: Bearer <token>",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+    
+    # Extract token
+    token = authorization[7:]  # Remove "Bearer " prefix
     if not token:
         raise HTTPException(
             status_code=401,
@@ -123,4 +119,4 @@ ValidatedVideo = Annotated[UploadFile, Depends(validate_video_file)]
 ExtractionParams = Annotated[ExtractionRequest, Depends(extraction_params)]
 Services = Annotated[ServiceContainer, Depends(get_services)]
 UseCases = Annotated[UseCaseContainer, Depends(get_use_cases)]
-BearerToken = Annotated[str, Depends(get_validated_token)]
+BearerToken = Annotated[str, Depends(validate_bearer_token)]

interfaces/api/routes/extraction_routes.py

@@ -22,12 +22,9 @@ router = APIRouter()
             description="""
             Extract audio from uploaded video file.
             
-            **Authentication Required**: This endpoint requires a valid JWT Bearer token.
-            
             All files are processed asynchronously and return a job ID for tracking progress.
             Use the job status endpoint to check processing status and download the result when complete.
             """,
-
             responses={
                 202: {
                     "description": "Job created for async processing",

interfaces/api/routes/job_routes.py

@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 @router.get("/jobs/{job_id}", 
            response_model=JobStatusResponse,
            summary="Get Job Status",
-           description="Check the status of an audio extraction job. **Authentication Required**: This endpoint requires a valid JWT Bearer token.",
+           description="Check the status of an audio extraction job",
            responses={
                200: {"description": "Job status retrieved successfully"},
                401: {"description": "Authentication required", "content": {"application/json": {"example": {"error": "Authentication required", "code": "AUTHENTICATION_ERROR"}}}},
@@ -78,8 +78,6 @@ async def get_job_status(
            description="""
            Download the audio file from a completed extraction job.
            
-           **Authentication Required**: This endpoint requires a valid JWT Bearer token.
-           
            Optionally specify start and end times to download only a portion of the audio:
            - start: Start time in HH:MM:SS format (e.g., 00:01:30 for 1 minute 30 seconds)
            - end: End time in HH:MM:SS format (e.g., 00:03:45 for 3 minutes 45 seconds)