my-youtube-api 1.0.4 → 1.0.6

package/dist/youtube-handlers/youtube-video-poster.d.ts

@@ -1,4 +1,3 @@
-import { youtube_v3 } from "googleapis";
 export interface VideoMetadata {
     title: string;
     description?: string;
@@ -21,45 +20,23 @@ export interface YouTubeUploadResult {
     thumbnailUrl?: string;
 }
 export declare class YoutubeVideoPoster {
-    private access_token;
+    private accessToken;
     private youtube;
-    constructor(access_token: string);
+    constructor(accessToken: string);
     /**
-     * Handle YouTube API errors and throw appropriate custom errors
+     * Upload a video from a Cloudinary URL to YouTube using direct API calls
      */
-    private handleYouTubeError;
+    uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult>;
     /**
-     * Validate video metadata
-     */
-    private validateMetadata;
-    /**
-     * Fetch video stream from URL with proper error handling
-     */
-    private fetchVideoStream;
-    /**
-     * Wait for video processing to complete
+     * Wait for video processing to complete using direct API calls
      */
     private waitForVideoProcessing;
     /**
-     * Add video to playlist if specified
-     */
-    private addToPlaylist;
-    /**
-     * Upload a video from a Cloudinary URL to YouTube
-     */
-    uploadFromCloudUrl2(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult>;
-    /**
-     * Upload a video from a Cloudinary URL to YouTube
-     * @param videoUrl URL of the video on Cloudinary
-     * @param metadata Video metadata
-     */
-    uploadFromCloudUrl(videoUrl: string, metadata: VideoMetadata): Promise<youtube_v3.Schema$Video>;
-    /**
-     * Get video details
+     * Alternative method using direct axios calls (if Google client still has issues)
      */
-    getVideoDetails(videoId: string): Promise<youtube_v3.Schema$Video>;
+    uploadFromCloudUrlDirect(videoUrl: string, metadata: VideoMetadata): Promise<YouTubeUploadResult>;
     /**
-     * Delete a video
+     * Wait for processing using direct API calls
      */
-    deleteVideo(videoId: string): Promise<void>;
+    private waitForVideoProcessingDirect;
 }

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

@@ -2,157 +2,118 @@
 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";
+import { YouTubeApiError, YouTubeAuthenticationError, YouTubeQuotaError, YouTubeMediaError, YouTubeUploadError, YouTubeValidationError, YouTubeProcessingError, YouTubeTimeoutError } from "../errors/youtube-api-errors";
 export class YoutubeVideoPoster {
-    constructor(access_token) {
-        this.access_token = access_token;
-        if (!access_token) {
+    constructor(accessToken) {
+        if (!accessToken) {
             throw new YouTubeAuthenticationError('Access token is required');
         }
-        this.youtube = google.youtube({ version: "v3", auth: this.access_token });
+        this.accessToken = accessToken;
+        // ✅ CORRECT: Create OAuth2 client and set credentials
+        const oauth2Client = new google.auth.OAuth2();
+        oauth2Client.setCredentials({
+            access_token: accessToken
+        });
+        this.youtube = google.youtube({
+            version: "v3",
+            auth: oauth2Client
+        });
     }
     /**
-     * Handle YouTube API errors and throw appropriate custom errors
+     * Upload a video from a Cloudinary URL to YouTube using direct API calls
      */
-    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) {
+    async uploadFromCloudUrl(videoUrl, metadata) {
+        let videoStream = null;
         try {
             console.log(`📹 Fetching video from: ${videoUrl}`);
+            // Fetch video stream
             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
+                timeout: 30000,
+                maxContentLength: 1024 * 1024 * 1024, // 1GB max
             });
-            if (!response.data || !(response.data instanceof Readable)) {
+            videoStream = response.data;
+            if (!videoStream || !(videoStream instanceof Readable)) {
                 throw new YouTubeMediaError('Invalid video stream received from URL');
             }
-            return response.data;
+            // Prepare metadata
+            const requestBody = {
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    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
+                }
+            };
+            console.log(`🚀 Uploading video to YouTube: "${metadata.title}"`);
+            // Upload using Google APIs client with OAuth2
+            const uploadResponse = await this.youtube.videos.insert({
+                part: ["snippet", "status"],
+                requestBody: requestBody,
+                media: {
+                    body: videoStream,
+                    mimeType: 'video/*'
+                },
+                notifySubscribers: metadata.notifySubscribers !== false
+            });
+            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);
+            const result = {
+                id: videoId,
+                status: 'processed',
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                title: metadata.title,
+                description: metadata.description,
+            };
+            console.log(`🎉 YouTube video published successfully: ${result.url}`);
+            return result;
         }
         catch (error) {
-            if (error instanceof YouTubeApiError) {
-                throw error;
+            // Clean up stream
+            if (videoStream) {
+                videoStream.destroy();
             }
-            if (error.response?.status === 404) {
-                throw new YouTubeMediaError(`Video not found at URL: ${videoUrl}`);
+            console.error("YouTube upload failed:", error);
+            // Handle specific Google API errors
+            if (error.code === 401) {
+                throw new YouTubeAuthenticationError('Authentication failed. Please reconnect your YouTube account. ' +
+                    'The access token may have expired or is invalid.');
             }
-            else if (error.response?.status === 403) {
-                throw new YouTubeMediaError(`Access denied to video URL: ${videoUrl}`);
+            else if (error.code === 403) {
+                if (error.message?.includes('quota')) {
+                    throw new YouTubeQuotaError('YouTube API quota exceeded. Please try again tomorrow.');
+                }
+                else {
+                    throw new YouTubeAuthenticationError('Access denied. Please check your YouTube permissions.');
+                }
             }
-            else if (error.code === 'ECONNABORTED') {
-                throw new YouTubeTimeoutError(`Timeout while fetching video from URL: ${videoUrl}`);
+            else if (error.code === 400) {
+                throw new YouTubeValidationError(`Invalid request: ${error.message}`);
+            }
+            else if (error.code === 503) {
+                throw new YouTubeProcessingError('YouTube service temporarily unavailable. Please try again.');
             }
             else {
-                throw new YouTubeMediaError(`Failed to fetch video from URL: ${error.message}`);
+                throw new YouTubeApiError(`YouTube API error: ${error.message}`);
             }
         }
     }
     /**
-     * Wait for video processing to complete
+     * Wait for video processing to complete using direct API calls
      */
-    async waitForVideoProcessing(videoId, timeoutMs = 300000 // 5 minutes
-    ) {
+    async waitForVideoProcessing(videoId, timeoutMs = 300000) {
         const startTime = Date.now();
         const maxAttempts = 30;
         let attempts = 0;
@@ -181,8 +142,7 @@ export class YoutubeVideoPoster {
                         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
+                        const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
                         console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
                         await new Promise(resolve => setTimeout(resolve, waitTime));
                         break;
@@ -195,173 +155,121 @@ export class YoutubeVideoPoster {
                 if (error instanceof YouTubeApiError) {
                     throw error;
                 }
-                this.handleYouTubeError(error, "Failed to check video processing status");
+                // Continue waiting on network errors
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
             }
         }
         throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
     }
     /**
-     * Add video to playlist if specified
+     * Alternative method using direct axios calls (if Google client still has issues)
      */
-    async addToPlaylist(videoId, playlistId) {
+    async uploadFromCloudUrlDirect(videoUrl, metadata) {
         try {
-            await this.youtube.playlistItems.insert({
-                part: ['snippet'],
-                requestBody: {
-                    snippet: {
-                        playlistId: playlistId,
-                        resourceId: {
-                            kind: 'youtube#video',
-                            videoId: videoId
-                        }
-                    }
-                }
+            console.log(`📹 Using direct upload method for: ${videoUrl}`);
+            // First, get the video file as buffer
+            const videoResponse = await axios.get(videoUrl, {
+                responseType: 'arraybuffer',
+                timeout: 30000,
             });
-            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 videoBuffer = Buffer.from(videoResponse.data);
+            // Prepare the metadata
             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
-                    }
+                snippet: {
+                    title: metadata.title.substring(0, 100),
+                    description: (metadata.description || "").substring(0, 5000),
+                    tags: metadata.tags || [],
+                    categoryId: metadata.categoryId || "22"
                 },
-                media: { body: videoStream }
+                status: {
+                    privacyStatus: metadata.privacyStatus || "private",
+                    embeddable: metadata.embeddable !== false,
+                    publicStatsViewable: metadata.publicStatsViewable !== false,
+                    license: metadata.license || "youtube",
+                    selfDeclaredMadeForKids: metadata.madeForKids || false
+                }
             };
-            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"));
+            // Upload using direct multipart request
+            const formData = new FormData();
+            formData.append('metadata', JSON.stringify(metadataPayload));
+            formData.append('video', new Blob([videoBuffer]), 'video.mp4');
+            const uploadResponse = await axios.post('https://www.googleapis.com/upload/youtube/v3/videos?part=snippet,status', formData, {
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'multipart/related',
+                },
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity,
+                timeout: 60000,
+            });
             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 = {
+            console.log(`✅ Video uploaded successfully via direct method: ${videoId}`);
+            // Wait for processing
+            await this.waitForVideoProcessingDirect(videoId);
+            return {
                 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();
+            console.error("Direct YouTube upload failed:", error.response?.data || error.message);
+            if (error.response?.status === 401) {
+                throw new YouTubeAuthenticationError('Authentication failed. Please reconnect your YouTube account.');
             }
-            if (error instanceof YouTubeApiError) {
-                throw error;
+            else if (error.response?.status === 403) {
+                throw new YouTubeQuotaError('YouTube API quota exceeded.');
+            }
+            else {
+                throw new YouTubeApiError(`Upload failed: ${error.message}`);
             }
-            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
+     * Wait for processing using direct API calls
      */
-    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
+    async waitForVideoProcessingDirect(videoId, timeoutMs = 300000) {
+        const startTime = Date.now();
+        let attempts = 0;
+        while (Date.now() - startTime < timeoutMs) {
+            attempts++;
+            try {
+                const response = await axios.get(`https://www.googleapis.com/youtube/v3/videos?part=status&id=${videoId}`, {
+                    headers: {
+                        'Authorization': `Bearer ${this.accessToken}`
                     }
-                },
-                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}`);
+                });
+                const video = response.data.items?.[0];
+                if (!video) {
+                    throw new YouTubeProcessingError(`Video ${videoId} not found`);
+                }
+                const status = video.status?.uploadStatus;
+                if (status === 'processed') {
+                    console.log(`✅ Video processing completed: ${videoId}`);
+                    return;
+                }
+                else if (status === 'failed') {
+                    throw new YouTubeProcessingError(`Video processing failed: ${video.status?.failureReason}`);
+                }
+                else if (status === 'rejected') {
+                    throw new YouTubeProcessingError(`Video rejected: ${video.status?.rejectionReason}`);
+                }
+                // Wait with exponential backoff
+                const waitTime = Math.min(1000 * Math.pow(2, attempts), 10000);
+                console.log(`⏳ Video status: ${status}, waiting ${waitTime}ms...`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+            catch (error) {
+                console.warn(`Error checking video status (attempt ${attempts}):`, error.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
             }
-            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");
         }
+        throw new YouTubeTimeoutError(`Video processing timed out after ${timeoutMs}ms`);
     }
 }

package/dist/youtube-handlers2/youtube-account-handler.d.ts

@@ -0,0 +1,21 @@
+interface Channel {
+    channelId: string;
+    title: string;
+    description: string;
+    thumbnail: string;
+}
+export declare class YoutubeAccountHandler {
+    private account_access_token;
+    /**
+     * Creates a new YoutubeAccountHandler instance
+     * @param account_access_token - The current access token for YouTube API authentication
+     */
+    constructor(account_access_token: string);
+    /**
+     * Fetches the list of YouTube channels associated with the authenticated account
+     * @returns Promise resolving to an array of Channel objects containing channel details
+     * @throws {AxiosError} If the API request fails due to authentication or other errors
+     */
+    fetchChannels(): Promise<Channel[]>;
+}
+export {};

package/dist/youtube-handlers2/youtube-account-handler.js

@@ -0,0 +1,33 @@
+import axios from "axios";
+import { YOUTUBE_BASE_URL } from "../error-utils";
+export class YoutubeAccountHandler {
+    /**
+     * Creates a new YoutubeAccountHandler instance
+     * @param account_access_token - The current access token for YouTube API authentication
+     */
+    constructor(account_access_token) {
+        this.account_access_token = account_access_token;
+    }
+    /**
+     * Fetches the list of YouTube channels associated with the authenticated account
+     * @returns Promise resolving to an array of Channel objects containing channel details
+     * @throws {AxiosError} If the API request fails due to authentication or other errors
+     */
+    async fetchChannels() {
+        const url = `${YOUTUBE_BASE_URL}/youtube/v3/channels`;
+        const params = {
+            part: "snippet,contentDetails,statistics",
+            mine: true,
+        };
+        const access_token = this.account_access_token;
+        const headers = { Authorization: `Bearer ${access_token}` };
+        const res = await axios.get(url, { params, headers });
+        const channels = res.data.items.map((ch) => ({
+            channelId: ch.id,
+            title: ch.snippet.title,
+            description: ch.snippet.description,
+            thumbnail: ch.snippet.thumbnails?.default?.url,
+        }));
+        return channels;
+    }
+}