my-youtube-api 1.0.4 → 1.0.5

package/dist/youtube-handlers2/youtube-video-poster.js

@@ -0,0 +1,367 @@
+// src/youtube-handlers/youtube-video-poster.ts
+import { google } 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 class YoutubeVideoPoster {
+    constructor(access_token) {
+        this.access_token = access_token;
+        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
+     */
+    handleYouTubeError(error, context) {
+        // 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
+     */
+    validateMetadata(metadata) {
+        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
+     */
+    async fetchVideoStream(videoUrl) {
+        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) {
+            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
+     */
+    async waitForVideoProcessing(videoId, timeoutMs = 300000 // 5 minutes
+    ) {
+        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) {
+                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
+     */
+    async addToPlaylist(videoId, playlistId) {
+        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) {
+            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
+     */
+    async uploadFromCloudUrl2(videoUrl, metadata) {
+        let videoStream = null;
+        try {
+            // Validate metadata first
+            this.validateMetadata(metadata);
+            // Fetch video stream
+            videoStream = await this.fetchVideoStream(videoUrl);
+            // Prepare metadata payload
+            const metadataPayload = {
+                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),
+                        categoryId: metadata.categoryId || "22"
+                    },
+                    status: {
+                        privacyStatus: metadata.privacyStatus || "private",
+                        embeddable: metadata.embeddable !== false,
+                        publicStatsViewable: metadata.publicStatsViewable !== false,
+                        license: metadata.license || "youtube",
+                        selfDeclaredMadeForKids: metadata.madeForKids || false
+                    }
+                },
+                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 = {
+                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) {
+            // 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");
+        }
+    }
+    /**
+     * Upload a video from a Cloudinary URL to YouTube
+     * @param videoUrl URL of the video on Cloudinary
+     * @param metadata Video metadata
+     */
+    async uploadFromCloudUrl(videoUrl, metadata) {
+        try {
+            // Fetch video as stream from Cloudinary
+            const response = await axios.get(videoUrl, { responseType: "stream" });
+            const videoStream = response.data;
+            // Prepare metadata payload
+            const metadataPayload = {
+                part: ["snippet", "status"],
+                requestBody: {
+                    snippet: {
+                        title: metadata.title.substring(0, 100),
+                        description: (metadata.description || "").substring(0, 5000),
+                        tags: (metadata.tags || []).slice(0, 5),
+                        categoryId: metadata.categoryId || "22"
+                    },
+                    status: {
+                        privacyStatus: metadata.privacyStatus || "private",
+                        embeddable: metadata.embeddable !== false,
+                        publicStatsViewable: metadata.publicStatsViewable !== false,
+                        license: metadata.license || "youtube",
+                        selfDeclaredMadeForKids: metadata.madeForKids || false
+                    }
+                },
+                media: { body: videoStream }
+            };
+            // Upload video
+            const res = await this.youtube.videos.insert(metadataPayload);
+            return res.data;
+        }
+        catch (error) {
+            console.error("YouTube upload failed:", error.response?.data || error.message);
+            throw new Error(`YouTube upload failed: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+    /**
+     * Get video details
+     */
+    async getVideoDetails(videoId) {
+        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;
+        }
+        catch (error) {
+            this.handleYouTubeError(error, "Failed to get video details");
+        }
+    }
+    /**
+     * Delete a video
+     */
+    async deleteVideo(videoId) {
+        try {
+            await this.youtube.videos.delete({
+                id: videoId
+            });
+            console.log(`✅ Video deleted successfully: ${videoId}`);
+        }
+        catch (error) {
+            this.handleYouTubeError(error, "Failed to delete video");
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-youtube-api",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "main": "dist/index.js",
   "scripts": {
     "prepublishOnly": "npm run build",