my-youtube-api 1.0.0 → 1.0.1

package/src/youtube-handlers copy/youtube-channel-handler.ts

@@ -0,0 +1,275 @@
+import axios from "axios";
+
+interface VideoAnalytics {
+    videoId: string;
+    title: string;
+    views: number;
+    likes: number;
+    comments: number;
+    publishedAt: string;
+    thumbnail: string;
+}
+
+interface ChannelAnalytics {
+    channelId: string;
+    title: string;
+    description: string;
+    thumbnail: string;
+    subscriberCount: number;
+    viewCount: number;
+    videoCount: number;
+    hiddenSubscriberCount: boolean;
+}
+
+
+interface AudienceAnalytics {
+    views: number;
+    estimatedMinutesWatched: number;
+    averageViewDuration: number;
+    subscribersGained: number;
+    subscribersLost: number;
+}
+
+
+interface VideoAnalytics {
+    videoId: string;
+    title: string;
+    views: number;
+    likes: number;
+    comments: number;
+    publishedAt: string;
+    thumbneil?: string;
+    videoType: "short" | "regular";
+}
+
+interface ChannelRevenue {
+    estimatedRevenue: number; // in USD
+    currency: string;
+    startDate: string;
+    endDate: string;
+}
+
+/* 
+. Enable YouTube Analytics API
+
+        Go to your Google Cloud Console → APIs & Services → Library → Search for and enable:
+
+        YouTube Analytics API
+
+        YouTube Reporting API
+
+        for report and analytics
+*/
+
+export class YoutubeChannelHandler {
+    private access_token: string;
+    private channel_id: string;
+
+    constructor(access_token: string, channel_id: string) {
+        this.access_token = access_token;
+        this.channel_id = channel_id;
+    }
+
+    /**
+     * Fetches basic channel statistics and information
+     * @returns Channel analytics including subscriber count, view count, and video count
+     */
+    async fetchChannelAnalytics(): Promise<ChannelAnalytics> {
+        const response = await axios.get("https://www.googleapis.com/youtube/v3/channels", {
+            params: {
+                part: "snippet,statistics,contentDetails",
+                mine: true // This gets the authenticated user's channel
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        const channel = response.data.items[0];
+
+        return {
+            channelId: channel.id,
+            title: channel.snippet.title,
+            description: channel.snippet.description,
+            thumbnail: channel.snippet.thumbnails?.high?.url,
+            subscriberCount: parseInt(channel.statistics.subscriberCount || '0'),
+            viewCount: parseInt(channel.statistics.viewCount || '0'),
+            videoCount: parseInt(channel.statistics.videoCount || '0'),
+            hiddenSubscriberCount: channel.statistics.hiddenSubscriberCount || false
+        };
+    }
+
+    /**
+     * Fetches analytics for all videos in the channel
+     * @param maxResults Maximum number of videos to fetch (default: 50, max: 50)
+     * @returns Array of video analytics including views, likes, and comments
+     */
+    async fetchVideos(maxResults: number = 50): Promise<VideoAnalytics[]> {
+        // 1️⃣ Get uploads playlist ID
+        const channelRes = await axios.get("https://www.googleapis.com/youtube/v3/channels", {
+            params: { part: "contentDetails", id: this.channel_id },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        const uploadsPlaylistId = channelRes.data.items[0]?.contentDetails?.relatedPlaylists?.uploads;
+        if (!uploadsPlaylistId) return [];
+
+        // 2️⃣ Fetch videos from the uploads playlist
+        const videosRes = await axios.get("https://www.googleapis.com/youtube/v3/playlistItems", {
+            params: {
+                part: "snippet,contentDetails",
+                playlistId: uploadsPlaylistId,
+                maxResults: Math.min(maxResults, 50),
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        const videoIds = videosRes.data.items.map((v: any) => v.contentDetails.videoId);
+        if (videoIds.length === 0) return [];
+
+        // 3️⃣ Fetch analytics & contentDetails for each video
+        const analyticsRes = await axios.get("https://www.googleapis.com/youtube/v3/videos", {
+            params: {
+                part: "snippet,statistics,contentDetails",
+                id: videoIds.join(","),
+                maxResults: Math.min(maxResults, 50),
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        return analyticsRes.data.items.map((video: any) => {
+            // Convert ISO 8601 duration to seconds
+            const duration = video.contentDetails?.duration || "PT0S";
+            const match = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+            const seconds =
+                (parseInt(match?.[1] || "0") * 3600) +
+                (parseInt(match?.[2] || "0") * 60) +
+                parseInt(match?.[3] || "0");
+
+            return {
+                videoId: video.id,
+                title: video.snippet.title,
+                views: parseInt(video.statistics.viewCount || 0),
+                likes: parseInt(video.statistics.likeCount || 0),
+                comments: parseInt(video.statistics.commentCount || 0),
+                publishedAt: video.snippet.publishedAt,
+                thumbnail: video.snippet.thumbnails?.high?.url,
+                videoType: seconds < 60 ? "short" : "regular",
+            };
+        });
+    }
+
+    /**
+     * Fetches audience analytics and engagement metrics for the channel
+     * @returns Audience analytics including view duration and subscriber changes
+     */
+    async fetchAudienceAnalytics(): Promise<AudienceAnalytics> {
+        try {
+
+            // 1️⃣ Compute proper date range (last 30 days)
+            const endDate = new Date();
+            const startDate = new Date();
+            startDate.setDate(endDate.getDate() - 30);
+
+            const formatDate = (date: Date) =>
+                date.toISOString().split("T")[0]; // YYYY-MM-DD
+
+            // 2️⃣ Call YouTube Analytics API
+            const response = await axios.get(
+                "https://youtubeanalytics.googleapis.com/v2/reports",
+                {
+                    params: {
+                        ids: `channel==${this.channel_id}`,
+                        startDate: formatDate(startDate),
+                        endDate: formatDate(endDate),
+                        metrics:
+                            "views,estimatedMinutesWatched,averageViewDuration,subscribersGained,subscribersLost",
+                        dimensions: "day",
+                    },
+                    headers: { Authorization: `Bearer ${this.access_token}` },
+                }
+            );
+
+            const rows: any[] = response.data.rows || [];
+
+            if (rows.length === 0) {
+                return {
+                    views: 0,
+                    estimatedMinutesWatched: 0,
+                    averageViewDuration: 0,
+                    subscribersGained: 0,
+                    subscribersLost: 0,
+                };
+            }
+
+            // 3️⃣ Sum up all daily metrics
+            const totals = rows.reduce(
+                (acc: any, row: any[]) => ({
+                    views: acc.views + Number(row[1] || 0),
+                    estimatedMinutesWatched:
+                        acc.estimatedMinutesWatched + Number(row[2] || 0),
+                    averageViewDuration: acc.averageViewDuration + Number(row[3] || 0),
+                    subscribersGained: acc.subscribersGained + Number(row[4] || 0),
+                    subscribersLost: acc.subscribersLost + Number(row[5] || 0),
+                }),
+                {
+                    views: 0,
+                    estimatedMinutesWatched: 0,
+                    averageViewDuration: 0,
+                    subscribersGained: 0,
+                    subscribersLost: 0,
+                }
+            );
+
+            // 4️⃣ Return final analytics
+            return {
+                views: totals.views,
+                estimatedMinutesWatched: totals.estimatedMinutesWatched,
+                averageViewDuration: totals.averageViewDuration / rows.length, // Average of averages
+                subscribersGained: totals.subscribersGained,
+                subscribersLost: totals.subscribersLost,
+            };
+        } catch (err) {
+            console.error("Error fetching audience analytics:", err);
+            return {
+                views: 0,
+                estimatedMinutesWatched: 0,
+                averageViewDuration: 0,
+                subscribersGained: 0,
+                subscribersLost: 0,
+            };
+        }
+    }
+
+    async fetchChannelRevenue(startDate: string = "2023-01-01", endDate: string = new Date().toISOString().split("T")[0]): Promise<ChannelRevenue> {
+        try {
+            const response = await axios.get("https://youtubeanalytics.googleapis.com/v2/reports", {
+                params: {
+                    ids: `channel==${this.channel_id}`,
+                    startDate,
+                    endDate,
+                    metrics: "estimatedRevenue",
+                    dimensions: "day", // optional: can remove to get total
+                    currency: "USD"
+                },
+                headers: {
+                    Authorization: `Bearer ${this.access_token}`
+                }
+            });
+
+            // Sum revenue if using "day" dimension
+            const totalRevenue = response.data.rows
+                ? response.data.rows.reduce((acc: number, row: any[]) => acc + parseFloat(row[1] || 0), 0)
+                : 0;
+
+            return {
+                estimatedRevenue: totalRevenue,
+                currency: "USD",
+                startDate,
+                endDate
+            };
+        } catch (err: any) {
+            console.error("Failed to fetch channel revenue:", err.response?.data || err.message);
+            return { estimatedRevenue: 0, currency: "USD", startDate, endDate };
+        }
+    }
+
+}

package/src/youtube-handlers copy/youtube-channel-handler2.ts

@@ -0,0 +1,249 @@
+import axios from "axios";
+
+interface GrowthMetrics {
+    subscribers: number;
+    totalVideoViews: number;
+    estimatedRevenue: number;
+    videosCount: number;
+    period: string;
+}
+
+interface SubscriberBalance {
+    subscribersGained: number;
+    subscribersLost: number;
+    netSubscribers: number;
+    videosPublished: number;
+    period: string;
+}
+
+interface VideoPerformance {
+    videoId: string;
+    title: string;
+    publishedAt: string;
+    views: number;
+    watchTime: number; // in minutes
+    avgViewDuration: number; // in seconds
+    likes: number;
+    dislikes: number;
+    comments: number;
+    shares: number;
+    thumbnail: string;
+}
+
+interface PublishedVideosStats {
+    totalViews: number;
+    totalLikes: number;
+    totalDislikes: number;
+    totalComments: number;
+    totalShares: number;
+    totalVideos: number;
+    averageEngagementRate: number;
+    period: string;
+}
+
+export class YoutubeAnalyticsHandler {
+    private access_token: string;
+    private channel_id: string;
+
+    constructor(access_token: string, channel_id: string) {
+        this.access_token = access_token;
+        this.channel_id = channel_id;
+    }
+
+    /**
+     * Fetches growth metrics for the channel over a specified period
+     * @param period Time period for growth analysis (7days, 30days, 90days, 365days)
+     * @returns Growth metrics including subscribers, views, revenue, and video count
+     * . Enable YouTube Analytics API
+
+        Go to your Google Cloud Console → APIs & Services → Library → Search for and enable:
+
+        YouTube Analytics API
+
+        YouTube Reporting API
+     */
+    async fetchGrowthMetrics(period: string = "30days"): Promise<GrowthMetrics> {
+        const endDate = "today";
+        const startDate = this.getStartDate(period);
+
+        // Fetch analytics data
+        const [analyticsResponse, channelResponse] = await Promise.all([
+            axios.get("https://youtubeanalytics.googleapis.com/v2/reports", {
+                params: {
+                    ids: `channel==${this.channel_id}`,
+                    startDate,
+                    endDate,
+                    metrics: "subscribersGained,views,estimatedRevenue",
+                    dimensions: "day"
+                },
+                headers: { Authorization: `Bearer ${this.access_token}` },
+            }),
+            this.fetchChannelBasicStats()
+        ]);
+
+        const rows = analyticsResponse.data.rows || [];
+
+        const totals = rows.reduce((acc: any, row: any[]) => ({
+            subscribersGained: acc.subscribersGained + (row[1] || 0),
+            views: acc.views + (row[2] || 0),
+            estimatedRevenue: acc.estimatedRevenue + (row[3] || 0)
+        }), { subscribersGained: 0, views: 0, estimatedRevenue: 0 });
+
+        return {
+            subscribers: totals.subscribersGained,
+            totalVideoViews: totals.views,
+            estimatedRevenue: totals.estimatedRevenue,
+            videosCount: channelResponse.videoCount,
+            period: `${startDate} to ${endDate}`
+        };
+    }
+
+    
+
+    /**
+     * Fetches aggregated statistics for all published videos in a period
+     * @param period Time period for analysis (7days, 30days, 90days)
+     * @returns Combined statistics for all published videos
+     */
+    async fetchPublishedVideosStats(period: string = "30days"): Promise<PublishedVideosStats> {
+        const endDate = "today";
+        const startDate = this.getStartDate(period);
+
+        const videos = await this.fetchVideosPublishedInPeriod(startDate, endDate);
+
+        if (videos.length === 0) {
+            return {
+                totalViews: 0,
+                totalLikes: 0,
+                totalDislikes: 0,
+                totalComments: 0,
+                totalShares: 0,
+                totalVideos: 0,
+                averageEngagementRate: 0,
+                period: `${startDate} to ${endDate}`
+            };
+        }
+
+        const videoIds = videos.map(v => v.videoId);
+        const videoStats = await this.fetchVideosDetailedStats(videoIds);
+
+        const totals = videoStats.reduce((acc: any, video: VideoPerformance) => ({
+            totalViews: acc.totalViews + video.views,
+            totalLikes: acc.totalLikes + video.likes,
+            totalDislikes: acc.totalDislikes + video.dislikes,
+            totalComments: acc.totalComments + video.comments,
+            totalShares: acc.totalShares + video.shares
+        }), { totalViews: 0, totalLikes: 0, totalDislikes: 0, totalComments: 0, totalShares: 0 });
+
+        const averageEngagementRate = ((totals.totalLikes + totals.totalComments + totals.totalShares) / totals.totalViews) * 100;
+
+        return {
+            totalViews: totals.totalViews,
+            totalLikes: totals.totalLikes,
+            totalDislikes: totals.totalDislikes,
+            totalComments: totals.totalComments,
+            totalShares: totals.totalShares,
+            totalVideos: videos.length,
+            averageEngagementRate: isNaN(averageEngagementRate) ? 0 : averageEngagementRate,
+            period: `${startDate} to ${endDate}`
+        };
+    }
+
+    /**
+     * Fetches detailed list of videos with comprehensive performance metrics
+     * @param maxResults Maximum number of videos to return (default: 50, max: 50)
+     * @returns Array of video performance metrics
+     */
+    async fetchVideosList(maxResults: number = 50): Promise<VideoPerformance[]> {
+        // Get uploads playlist ID
+        const channelRes = await axios.get("https://www.googleapis.com/youtube/v3/channels", {
+            params: { part: "contentDetails", id: this.channel_id },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        const uploadsPlaylistId = channelRes.data.items[0]?.contentDetails?.relatedPlaylists?.uploads;
+        if (!uploadsPlaylistId) return [];
+
+        // Fetch videos from uploads playlist
+        const videosRes = await axios.get("https://www.googleapis.com/youtube/v3/playlistItems", {
+            params: {
+                part: "snippet,contentDetails",
+                playlistId: uploadsPlaylistId,
+                maxResults: Math.min(maxResults, 50)
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        const videoIds = videosRes.data.items.map((v: any) => v.contentDetails.videoId);
+        if (videoIds.length === 0) return [];
+
+        // Fetch detailed statistics for each video
+        return await this.fetchVideosDetailedStats(videoIds);
+    }
+
+    // ============ HELPER METHODS ============
+
+    private async fetchChannelBasicStats(): Promise<{ videoCount: number }> {
+        const response = await axios.get("https://www.googleapis.com/youtube/v3/channels", {
+            params: {
+                part: "statistics",
+                id: this.channel_id
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        return {
+            videoCount: parseInt(response.data.items[0]?.statistics?.videoCount || 0)
+        };
+    }
+
+    private async fetchVideosPublishedInPeriod(startDate: string, endDate: string): Promise<any[]> {
+        const videos = await this.fetchVideosList(100); // Get more videos for period filtering
+
+        return videos.filter(video => {
+            const publishedDate = new Date(video.publishedAt).toISOString().split('T')[0];
+            return publishedDate >= startDate && publishedDate <= endDate;
+        });
+    }
+
+    private async fetchVideosDetailedStats(videoIds: string[]): Promise<VideoPerformance[]> {
+        const response = await axios.get("https://www.googleapis.com/youtube/v3/videos", {
+            params: {
+                part: "snippet,statistics,contentDetails",
+                id: videoIds.join(','),
+                maxResults: videoIds.length
+            },
+            headers: { Authorization: `Bearer ${this.access_token}` },
+        });
+
+        return response.data.items.map((video: any) => ({
+            videoId: video.id,
+            title: video.snippet.title,
+            publishedAt: video.snippet.publishedAt,
+            views: parseInt(video.statistics.viewCount || 0),
+            watchTime: parseInt(video.statistics.watchTime || 0) / 60, // Convert to minutes
+            avgViewDuration: parseInt(video.statistics.averageViewDuration || 0),
+            likes: parseInt(video.statistics.likeCount || 0),
+            dislikes: parseInt(video.statistics.dislikeCount || 0),
+            comments: parseInt(video.statistics.commentCount || 0),
+            shares: parseInt(video.statistics.shareCount || 0),
+            thumbnail: video.snippet.thumbnails?.high?.url
+        }));
+    }
+
+    private getStartDate(period: string): string {
+        const days = parseInt(period);
+        if (!isNaN(days)) {
+            return `${days}daysAgo`;
+        }
+
+        const periodMap: { [key: string]: string } = {
+            "7days": "7daysAgo",
+            "30days": "30daysAgo",
+            "90days": "90daysAgo",
+            "365days": "365daysAgo"
+        };
+
+        return periodMap[period] || "30daysAgo";
+    }
+}

package/src/youtube-handlers copy/youtube-video-handler.ts

@@ -0,0 +1,87 @@
+import axios from "axios";
+
+
+interface CommentReply {
+    replyId: string;
+    author: string;
+    text: string;
+    likeCount: number;
+    publishedAt: string;
+}
+interface CommentAnalyticsWithReplies {
+    commentId: string;
+    videoId: string;
+    author: string;
+    text: string;
+    likeCount: number;
+    publishedAt: string;
+    replyCount: number;
+    replies: CommentReply[];
+}
+export class YoutubeVideoHandler {
+
+    private video_id: string;
+    private access_token: string;
+
+    constructor(access_token: string, video_id: string) {
+        this.access_token = access_token;
+        this.video_id = video_id;
+    }
+
+    /**
+    * Fetches comments analytics for a specific video or all channel videos
+    * @param videoId Optional video ID - if not provided, fetches comments from all channel videos
+    * @param maxResults Maximum number of comments to fetch per video (default: 20, max: 100)
+    * @returns Array of comment analytics including like counts and reply counts
+    */
+    async fetchCommentsAnalytics(maxResults: number = 20): Promise<CommentAnalyticsWithReplies[]> {
+        const targetVideoIds: string[] = [this.video_id];
+        const allComments: CommentAnalyticsWithReplies[] = [];
+
+        for (const vid of targetVideoIds) {
+            try {
+                const response = await axios.get("https://www.googleapis.com/youtube/v3/commentThreads", {
+                    params: {
+                        part: "snippet,replies",
+                        videoId: vid,
+                        maxResults: Math.min(maxResults, 100),
+                        order: "relevance"
+                    },
+                    headers: { Authorization: `Bearer ${this.access_token}` },
+                });
+
+                for (const item of response.data.items) {
+                    const topComment = item.snippet.topLevelComment.snippet;
+
+                    const replies: CommentReply[] = (item.replies?.comments || []).map((rep: any) => ({
+                        replyId: rep.id,
+                        author: rep.snippet.authorDisplayName,
+                        text: rep.snippet.textDisplay,
+                        likeCount: rep.snippet.likeCount,
+                        publishedAt: rep.snippet.publishedAt
+                    }));
+
+                    allComments.push({
+                        commentId: item.id,
+                        videoId: vid,
+                        author: topComment.authorDisplayName,
+                        text: topComment.textDisplay,
+                        likeCount: topComment.likeCount,
+                        publishedAt: topComment.publishedAt,
+                        replyCount: item.snippet.totalReplyCount,
+                        replies
+                    });
+                }
+            } catch (error) {
+                console.warn(`Failed to fetch comments for video ${vid}:`, error);
+                continue;
+            }
+        }
+
+        return allComments;
+    }
+    
+
+    
+
+}

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

@@ -0,0 +1,65 @@
+import { google, youtube_v3 } from "googleapis";
+import axios from "axios";
+import { Readable } from "stream";
+
+export interface VideoMetadata {
+    title: string;
+    description?: string;
+    tags?: string[];
+    categoryId?: string;
+    privacyStatus?: "public" | "private" | "unlisted";
+    madeForKids?: boolean;
+    license?: "youtube" | "creativeCommon";
+    embeddable?: boolean;
+    publicStatsViewable?: boolean;
+}
+
+export class YoutubeVideoPoster {
+    private youtube: youtube_v3.Youtube;
+
+    constructor(private access_token: string) {
+        this.youtube = google.youtube({ version: "v3", auth: this.access_token });
+    }
+
+    /**
+     * 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<youtube_v3.Schema$Video> {
+        try {
+            // 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"],
+                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: any) {
+            console.error("YouTube upload failed:", error.response?.data || error.message);
+            throw new Error(`YouTube upload failed: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+}