my-youtube-api 1.0.3 → 1.0.5

package/src/youtube-handlers/youtube-video-poster.ts

@@ -1,18 +1,6 @@
-// src/youtube-handlers/youtube-video-poster.ts
 import { google, youtube_v3 } from "googleapis";
 import axios from "axios";
 import { Readable } from "stream";
-import {
-    YouTubeApiError,
-    YouTubeAuthenticationError,
-    YouTubeQuotaError,
-    YouTubeRateLimitError,
-    YouTubeMediaError,
-    YouTubeUploadError,
-    YouTubeValidationError,
-    YouTubeProcessingError,
-    YouTubeTimeoutError
-} from "../errors/youtube-api-errors";
 
 export interface VideoMetadata {
     title: string;
@@ -21,299 +9,37 @@ export interface VideoMetadata {
     categoryId?: string;
     privacyStatus?: "public" | "private" | "unlisted";
     madeForKids?: boolean;
-    license?: "youtube" | "creativeCommon";
+    license?: "youtube" | "creativeCommon"; 
     embeddable?: boolean;
     publicStatsViewable?: boolean;
-    playlistId?: string;
-    notifySubscribers?: boolean;
-}
-
-export interface YouTubeUploadResult {
-    id: string;
-    status: string;
-    url: string;
-    title: string;
-    description?: string;
-    thumbnailUrl?: string;
 }
 
 export class YoutubeVideoPoster {
     private youtube: youtube_v3.Youtube;
 
     constructor(private access_token: string) {
-        if (!access_token) {
-            throw new YouTubeAuthenticationError('Access token is required');
-        }
         this.youtube = google.youtube({ version: "v3", auth: this.access_token });
     }
 
-    /**
-     * Handle YouTube API errors and throw appropriate custom errors
-     */
-    private handleYouTubeError(error: any, context: string): never {
-        // Handle Google API errors
-        if (error.errors && Array.isArray(error.errors)) {
-            const apiError = error.errors[0];
-            const message = `${context}: ${apiError.message}`;
-            const reason = apiError.reason;
-            const domain = apiError.domain;
-
-            switch (reason) {
-                case 'authError':
-                case 'invalidCredentials':
-                case 'required':
-                    throw new YouTubeAuthenticationError(message, apiError);
-                
-                case 'quotaExceeded':
-                case 'dailyLimitExceeded':
-                case 'userRateLimitExceeded':
-                    throw new YouTubeQuotaError(message, apiError);
-                
-                case 'rateLimitExceeded':
-                case 'userRateLimitExceeded':
-                    throw new YouTubeRateLimitError(message, apiError);
-                
-                case 'invalidValue':
-                case 'invalid':
-                    throw new YouTubeValidationError(message, apiError);
-                
-                case 'processingFailed':
-                case 'failed':
-                    throw new YouTubeProcessingError(message, apiError);
-                
-                default:
-                    throw new YouTubeApiError(message, `YOUTUBE_${reason?.toUpperCase()}`, error.code, apiError);
-            }
-        }
-
-        // Handle axios/network errors
-        if (error.response?.data?.error) {
-            const youtubeError = error.response.data.error;
-            const message = `${context}: ${youtubeError.message}`;
-            const code = youtubeError.code;
-
-            switch (code) {
-                case 401:
-                case 403:
-                    throw new YouTubeAuthenticationError(message, youtubeError);
-                case 429:
-                    throw new YouTubeRateLimitError(message, youtubeError);
-                case 400:
-                    throw new YouTubeValidationError(message, youtubeError);
-                case 500:
-                case 503:
-                    throw new YouTubeProcessingError(message, youtubeError);
-                default:
-                    throw new YouTubeApiError(message, `YOUTUBE_${code}`, code, youtubeError);
-            }
-        }
-
-        // Handle timeout errors
-        if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
-            throw new YouTubeTimeoutError(`${context}: Request timed out`, error);
-        }
-
-        // Handle network errors
-        if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
-            throw new YouTubeApiError(`${context}: Network error - ${error.message}`, 'NETWORK_ERROR', 503);
-        }
-
-        // Handle media/upload specific errors
-        if (error.message?.includes('stream') || error.message?.includes('video') || error.message?.includes('upload')) {
-            throw new YouTubeUploadError(`${context}: ${error.message}`, error);
-        }
-
-        // Default to generic API error
-        if (error instanceof YouTubeApiError) {
-            throw error;
-        }
-
-        throw new YouTubeApiError(`${context}: ${error.message}`, 'UNKNOWN_ERROR', error.response?.status);
-    }
-
-    /**
-     * Validate video metadata
-     */
-    private validateMetadata(metadata: VideoMetadata): void {
-        if (!metadata.title || metadata.title.trim().length === 0) {
-            throw new YouTubeValidationError('Video title is required');
-        }
-
-        if (metadata.title.length > 100) {
-            throw new YouTubeValidationError('Video title must be 100 characters or less');
-        }
-
-        if (metadata.description && metadata.description.length > 5000) {
-            throw new YouTubeValidationError('Video description must be 5000 characters or less');
-        }
-
-        if (metadata.tags && metadata.tags.length > 500) {
-            throw new YouTubeValidationError('Maximum 500 tags allowed');
-        }
-
-        if (metadata.tags) {
-            for (const tag of metadata.tags) {
-                if (tag.length > 30) {
-                    throw new YouTubeValidationError(`Tag "${tag}" must be 30 characters or less`);
-                }
-            }
-        }
-
-        const validPrivacyStatuses = ['public', 'private', 'unlisted'];
-        if (metadata.privacyStatus && !validPrivacyStatuses.includes(metadata.privacyStatus)) {
-            throw new YouTubeValidationError(`Privacy status must be one of: ${validPrivacyStatuses.join(', ')}`);
-        }
-
-        const validLicenses = ['youtube', 'creativeCommon'];
-        if (metadata.license && !validLicenses.includes(metadata.license)) {
-            throw new YouTubeValidationError(`License must be one of: ${validLicenses.join(', ')}`);
-        }
-    }
-
-    /**
-     * Fetch video stream from URL with proper error handling
-     */
-    private async fetchVideoStream(videoUrl: string): Promise<Readable> {
-        try {
-            console.log(`📹 Fetching video from: ${videoUrl}`);
-
-            const response = await axios.get(videoUrl, {
-                responseType: "stream",
-                timeout: 30000, // 30 second timeout
-                maxContentLength: 1024 * 1024 * 1024, // 1GB max file size
-                validateStatus: (status) => status === 200
-            });
-
-            if (!response.data || !(response.data instanceof Readable)) {
-                throw new YouTubeMediaError('Invalid video stream received from URL');
-            }
-
-            return response.data;
-
-        } catch (error: any) {
-            if (error instanceof YouTubeApiError) {
-                throw error;
-            }
-
-            if (error.response?.status === 404) {
-                throw new YouTubeMediaError(`Video not found at URL: ${videoUrl}`);
-            } else if (error.response?.status === 403) {
-                throw new YouTubeMediaError(`Access denied to video URL: ${videoUrl}`);
-            } else if (error.code === 'ECONNABORTED') {
-                throw new YouTubeTimeoutError(`Timeout while fetching video from URL: ${videoUrl}`);
-            } else {
-                throw new YouTubeMediaError(`Failed to fetch video from URL: ${error.message}`);
-            }
-        }
-    }
-
-    /**
-     * Wait for video processing to complete
-     */
-    private async waitForVideoProcessing(
-        videoId: string,
-        timeoutMs: number = 300000 // 5 minutes
-    ): Promise<void> {
-        const startTime = Date.now();
-        const maxAttempts = 30;
-        let attempts = 0;
-
-        console.log(`⏳ Waiting for video processing: ${videoId}`);
-
-        while (attempts < maxAttempts && Date.now() - startTime < timeoutMs) {
-            attempts++;
-
-            try {
-                const statusResponse = await this.youtube.videos.list({
-                    part: ['status'],
-                    id: [videoId]
-                });
-
-                const video = statusResponse.data.items?.[0];
-                if (!video) {
-                    throw new YouTubeProcessingError(`Video ${videoId} not found after upload`);
-                }
-
-                const status = video.status?.uploadStatus;
-
-                switch (status) {
-                    case 'processed':
-                        console.log(`✅ Video processing completed: ${videoId}`);
-                        return;
-                    case 'failed':
-                        const failureReason = video.status?.failureReason || 'Unknown failure reason';
-                        throw new YouTubeProcessingError(`Video processing failed: ${failureReason}`);
-                    case 'rejected':
-                        const rejectionReason = video.status?.rejectionReason || 'Unknown rejection reason';
-                        throw new YouTubeProcessingError(`Video was rejected: ${rejectionReason}`);
-                    case 'uploaded':
-                    case 'processing':
-                        // Wait and check again
-                        const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000); // Exponential backoff, max 10s
-                        console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
-                        await new Promise(resolve => setTimeout(resolve, waitTime));
-                        break;
-                    default:
-                        await new Promise(resolve => setTimeout(resolve, 5000));
-                        break;
-                }
-            } catch (error: any) {
-                if (error instanceof YouTubeApiError) {
-                    throw error;
-                }
-                this.handleYouTubeError(error, "Failed to check video processing status");
-            }
-        }
-
-        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
-    }
-
-    /**
-     * Add video to playlist if specified
-     */
-    private async addToPlaylist(videoId: string, playlistId: string): Promise<void> {
-        try {
-            await this.youtube.playlistItems.insert({
-                part: ['snippet'],
-                requestBody: {
-                    snippet: {
-                        playlistId: playlistId,
-                        resourceId: {
-                            kind: 'youtube#video',
-                            videoId: videoId
-                        }
-                    }
-                }
-            });
-            console.log(`✅ Video ${videoId} added to playlist ${playlistId}`);
-        } catch (error: any) {
-            console.warn(`⚠️ Failed to add video to playlist: ${error.message}`);
-            // Don't throw error for playlist addition failure as video upload was successful
-        }
-    }
-
     /**
      * Upload a video from a Cloudinary URL to YouTube
+     * @param videoUrl URL of the video on Cloudinary
+     * @param metadata Video metadata
      */
-    public async uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult> {
-        let videoStream: Readable | null = null;
-
+    public async uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<youtube_v3.Schema$Video> {
         try {
-            // Validate metadata first
-            this.validateMetadata(metadata);
-
-            // Fetch video stream
-            videoStream = await this.fetchVideoStream(videoUrl);
+            // Fetch video as stream from Cloudinary
+            const response = await axios.get(videoUrl, { responseType: "stream" });
+            const videoStream = response.data as Readable;
 
             // Prepare metadata payload
             const metadataPayload: youtube_v3.Params$Resource$Videos$Insert = {
                 part: ["snippet", "status"],
-                notifySubscribers: metadata.notifySubscribers !== false,
                 requestBody: {
                     snippet: {
                         title: metadata.title.substring(0, 100),
                         description: (metadata.description || "").substring(0, 5000),
-                        tags: (metadata.tags || []).slice(0, 500),
+                        tags: (metadata.tags || []).slice(0, 5),
                         categoryId: metadata.categoryId || "22"
                     },
                     status: {
@@ -327,88 +53,13 @@ export class YoutubeVideoPoster {
                 media: { body: videoStream }
             };
 
-            console.log(`🚀 Uploading video to YouTube: "${metadata.title}"`);
-
             // Upload video
-            const uploadResponse = await this.youtube.videos.insert(metadataPayload)
-                .catch(error => this.handleYouTubeError(error, "Failed to upload video to YouTube"));
-
-            const videoId = uploadResponse.data.id;
-
-            if (!videoId) {
-                throw new YouTubeUploadError('Video ID not returned from YouTube API');
-            }
-
-            console.log(`✅ Video uploaded successfully: ${videoId}`);
-
-            // Wait for processing to complete
-            await this.waitForVideoProcessing(videoId);
-
-            // Add to playlist if specified
-            if (metadata.playlistId) {
-                await this.addToPlaylist(videoId, metadata.playlistId);
-            }
-
-            const result: YouTubeUploadResult = {
-                id: videoId,
-                status: 'processed',
-                url: `https://www.youtube.com/watch?v=${videoId}`,
-                title: metadata.title,
-                description: metadata.description,
-                // You can add thumbnail URL here if needed
-            };
-
-            console.log(`🎉 YouTube video published successfully: ${result.url}`);
-
-            return result;
-
-        } catch (error: any) {
-            // Clean up stream if it exists
-            if (videoStream) {
-                videoStream.destroy();
-            }
-
-            if (error instanceof YouTubeApiError) {
-                throw error;
-            }
-
-            this.handleYouTubeError(error, "Unexpected error during YouTube video upload");
-        }
-    }
-
-    /**
-     * Get video details
-     */
-    public async getVideoDetails(videoId: string): Promise<youtube_v3.Schema$Video> {
-        try {
-            const response = await this.youtube.videos.list({
-                part: ['snippet', 'status', 'contentDetails', 'statistics'],
-                id: [videoId]
-            });
-
-            const video = response.data.items?.[0];
-            if (!video) {
-                throw new YouTubeValidationError(`Video not found: ${videoId}`);
-            }
-
-            return video;
+            const res = await this.youtube.videos.insert(metadataPayload);
+            return res.data;
 
         } catch (error: any) {
-            this.handleYouTubeError(error, "Failed to get video details");
+            console.error("YouTube upload failed:", error.response?.data || error.message);
+            throw new Error(`YouTube upload failed: ${error.response?.data?.error?.message || error.message}`);
         }
     }
-
-    /**
-     * Delete a video
-     */
-    public async deleteVideo(videoId: string): Promise<void> {
-        try {
-            await this.youtube.videos.delete({
-                id: videoId
-            });
-            console.log(`✅ Video deleted successfully: ${videoId}`);
-        } catch (error: any) {
-            this.handleYouTubeError(error, "Failed to delete video");
-        }
-    }
-}
+}