my-youtube-api 1.0.0

package/dist/youtube-handlers/youtube-channel-handler2.js

@@ -0,0 +1,177 @@
+import axios from "axios";
+export class YoutubeAnalyticsHandler {
+    constructor(access_token, channel_id) {
+        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 = "30days") {
+        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, row) => ({
+            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 = "30days") {
+        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, video) => ({
+            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 = 50) {
+        // 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) => v.contentDetails.videoId);
+        if (videoIds.length === 0)
+            return [];
+        // Fetch detailed statistics for each video
+        return await this.fetchVideosDetailedStats(videoIds);
+    }
+    // ============ HELPER METHODS ============
+    async fetchChannelBasicStats() {
+        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)
+        };
+    }
+    async fetchVideosPublishedInPeriod(startDate, endDate) {
+        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;
+        });
+    }
+    async fetchVideosDetailedStats(videoIds) {
+        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) => ({
+            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
+        }));
+    }
+    getStartDate(period) {
+        const days = parseInt(period);
+        if (!isNaN(days)) {
+            return `${days}daysAgo`;
+        }
+        const periodMap = {
+            "7days": "7daysAgo",
+            "30days": "30daysAgo",
+            "90days": "90daysAgo",
+            "365days": "365daysAgo"
+        };
+        return periodMap[period] || "30daysAgo";
+    }
+}

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

@@ -0,0 +1,30 @@
+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 declare class YoutubeVideoHandler {
+    private video_id;
+    private access_token;
+    constructor(access_token: string, video_id: string);
+    /**
+    * 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
+    */
+    fetchCommentsAnalytics(maxResults?: number): Promise<CommentAnalyticsWithReplies[]>;
+}
+export {};

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

@@ -0,0 +1,55 @@
+import axios from "axios";
+export class YoutubeVideoHandler {
+    constructor(access_token, video_id) {
+        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 = 20) {
+        const targetVideoIds = [this.video_id];
+        const allComments = [];
+        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 = (item.replies?.comments || []).map((rep) => ({
+                        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/dist/youtube-handlers/youtube-video-poster.d.ts

@@ -0,0 +1,23 @@
+import { youtube_v3 } from "googleapis";
+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 declare class YoutubeVideoPoster {
+    private access_token;
+    private youtube;
+    constructor(access_token: string);
+    /**
+     * 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>;
+}

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

@@ -0,0 +1,47 @@
+import { google } from "googleapis";
+import axios from "axios";
+export class YoutubeVideoPoster {
+    constructor(access_token) {
+        this.access_token = access_token;
+        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
+     */
+    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}`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "my-youtube-api",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "test": "ts-node src/test.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "types": "dist/index.d.ts",
+  "type": "module", 
+  "dependencies": {
+    "axios": "^1.12.2",
+    "googleapis": "^160.0.0",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "@types/dotenv": "^6.1.1",
+    "@types/node": "^24.5.1",
+    "typescript": "^5.9.2"
+  }
+}

package/src/error-utils.ts

@@ -0,0 +1,38 @@
+export const YOUTUBE_BASE_URL = "https://www.googleapis.com";
+
+
+export const RUPLOAD_URL = 'https://rupload.facebook.com';
+
+
+export enum FacebookErrorCode {
+  NO_ACCOUNT = 'NO_ACCOUNT',
+  ACCESS_TOKEN_EXPIRED = 'ACCESS_TOKEN_EXPIRED',
+  FAILED_GET_PAGES = 'FAILED_GET_PAGES',
+  ACCESS_TOKEN_INVALID = 'ACCESS_TOKEN_INVALID',
+  PAGE_NOT_FOUND = 'PAGE_NOT_FOUND',
+  PAGE_ACCESS_TOKEN_EXPIRE = 'PAGE_ACCESS_TOKEN_EXPIRE',
+  FAILED_FETCH_PAGES_FROM_API = 'FAILED_FETCH_PAGES_FROM_API'
+}
+
+const errorMessages: Record<FacebookErrorCode, string> = {
+  [FacebookErrorCode.NO_ACCOUNT]: 'Facebook account not connected',
+  [FacebookErrorCode.ACCESS_TOKEN_EXPIRED]: 'Facebook access token has expired',
+  [FacebookErrorCode.FAILED_GET_PAGES]: 'Failed to fetch Facebook pages',
+  [FacebookErrorCode.ACCESS_TOKEN_INVALID]: 'Facebook access token is invalid',
+  [FacebookErrorCode.PAGE_NOT_FOUND]: 'Facebook page not found',
+  [FacebookErrorCode.PAGE_ACCESS_TOKEN_EXPIRE]: 'Facebook page access token has expired',
+  [FacebookErrorCode.FAILED_FETCH_PAGES_FROM_API]: 'Failed to fetch pages from Facebook API'
+};
+
+ 
+export class FacebookError extends Error {
+  constructor(
+    public code: FacebookErrorCode,
+    public originalError?: any
+  ) {
+    super(errorMessages[code]);
+    this.name = 'FacebookError';
+  }
+}
+ 
+ 

package/src/index.ts

@@ -0,0 +1,22 @@
+import { YoutubeAccountHandler } from "./youtube-handlers/youtube-account-handler";
+import { YoutubeChannelHandler } from "./youtube-handlers/youtube-channel-handler";
+import { YoutubeVideoHandler } from "./youtube-handlers/youtube-video-handler";
+import { YoutubeVideoPoster } from "./youtube-handlers/youtube-video-poster";
+
+/* 
+npm run build
+npm pack
+
+in nextjs go to this package/"my-youtube-api-1.0.0.tgz"
+*/
+
+import { isValidAccessToken, fetchNewAccessToken } from './utils'
+
+export {
+    YoutubeAccountHandler,
+    YoutubeChannelHandler,
+    YoutubeVideoHandler,
+    YoutubeVideoPoster,
+    isValidAccessToken,
+    fetchNewAccessToken
+};

package/src/test.ts

@@ -0,0 +1,50 @@
+import { YoutubeChannelHandler } from "./youtube-handlers/youtube-channel-handler";
+import { YoutubeAnalyticsHandler } from "./youtube-handlers/youtube-channel-handler2";
+import { YoutubeVideoHandler } from "./youtube-handlers/youtube-video-handler";
+
+const access_token="ya29.a0AQQ_BDSZ2rCrjvxUbkkVtbVtWdstheMCiFoBLDwCLcOkcPVdej3wmFbraxVoVuhTNd875VIOA_hjWj7bPom8AJbRzfDL3roL3OIaLVP2egffiMo0lPScLLK4RuwA16JmdVeJadeNiMofUtfhqdwjz9JRHQ2DBhUYRwzwCAZzPTX9kUU4d4v43TePdZ9Pm1AoCNnGLEQaCgYKAQYSARUSFQHGX2MiEjdmyiMSsAh6MyI_w17C8Q0206";
+const channel_id="UCfRRVg_MwvlFWqsvBUXrXcw";
+const video_id="J-Rn69UHm78";
+
+/* 
+"main": "dist/index.js",
+for nextjs:
+    in package json:  "type": "module", "types": "dist/index.d.ts",
+    in tsconfig.json: "module": "ESNext", 
+for testing here:
+    in package json:  remove "type": "module", and "type": "module"
+    in tsconfig.json: "module": "commonjs", 
+*/
+
+/* 
+
+npm run build
+npm pack
+
+in nextjs go to this package/"my-facebook-api-1.0.0.tgz"
+
+*/
+
+
+const youtubeChannelHandler = new YoutubeChannelHandler(access_token,channel_id);
+
+/* youtubeChannelHandler.getChannelStats().then((res)=>{
+    console.log('================================================');
+    console.log(res,'wwwwwwwwwwwwwww');
+    
+})
+ */
+const youtubeAnalyticsHandlers = new YoutubeAnalyticsHandler(access_token,channel_id);
+
+/* youtubeAnalyticsHandlers.fetchVideosList().then((res)=>{
+    console.log(res,'wwwwwwwwwwwwwwwwwwwwwwwwww');
+    
+}) */
+
+
+const youvid = new YoutubeVideoHandler(access_token,video_id);
+
+/* youvid.getYouTubeComments().then((res)=>{
+    console.log(res,res[0].replies,'eeeeeeeeeeeeeeeeeeeeeeeeeeeee');
+    
+}) */

package/src/utils.ts

@@ -0,0 +1,85 @@
+import axios from "axios";
+interface AccessTokenType {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  refresh_token_expires_in: number;
+  expires_at: number;
+}
+/**
+ * Checks whether a Google access token is still valid.
+ * @param accessToken - The access token to verify.
+ * @returns true if valid, false otherwise.
+ */
+export async function isValidAccessToken(accessToken: string | null): Promise<boolean> {
+  if (!accessToken) return false;
+
+  try {
+    const response = await axios.get("https://www.googleapis.com/oauth2/v1/tokeninfo", {
+      params: { access_token: accessToken },
+    });
+
+    // The tokeninfo endpoint returns an error if the token is invalid,
+    // so if we get here, it's valid.
+    return response.status === 200;
+  } catch (error) {
+    return false; // expired or invalid token
+  }
+}
+
+
+
+/**
+   * Refreshes an expired access token using a valid refresh token
+   * @param valid_refresh_token - The refresh token obtained during initial OAuth2 authentication
+   * @returns Promise resolving to AccessTokenType object containing new tokens and expiration information
+   * @throws {AxiosError} If the token refresh request fails (invalid refresh token, client credentials, etc.)
+   * 
+   * @remarks
+   * All time-related values are returned in seconds:
+   * - expires_in: Lifetime of the access token in seconds (typically 3600)
+   * - expires_at: Unix timestamp in seconds when the access token will expire
+   * - refresh_token_expires_in: Lifetime of the refresh token in seconds (if provided by Google)
+   */
+export async function fetchNewAccessToken(
+  valid_refresh_token: string,
+  google_client_id: string,
+  google_client_secret: string
+): Promise<AccessTokenType> {
+  try {
+    const params = new URLSearchParams({
+      client_id: google_client_id,
+      client_secret: google_client_secret,
+      grant_type: "refresh_token",
+      refresh_token: valid_refresh_token,
+    });
+
+    const response = await axios.post(
+      "https://oauth2.googleapis.com/token",
+      params.toString(),
+      { headers: { "Content-Type": "application/x-www-form-urlencoded" } }
+    );
+
+    const data = response.data;
+    const access_token = data.access_token;
+    const expires_in = data.expires_in;
+    const refresh_token = data.refresh_token ?? valid_refresh_token;
+    const refresh_token_expires_in = data.refresh_token_expires_in;
+    const expires_at = Math.floor(Date.now() / 1000) + expires_in;
+
+    return {
+      access_token,
+      expires_at,
+      refresh_token_expires_in,
+      expires_in,
+      refresh_token,
+    };
+  } catch (error: any) {
+    console.error(
+      "❌ Failed to refresh access token:",
+      error.response?.data || error.message
+    );
+    throw error;
+  }
+}
+

package/src/youtube-handlers/youtube-account-handler.ts

@@ -0,0 +1,51 @@
+import axios from "axios";
+import { YOUTUBE_BASE_URL } from "../error-utils";
+
+interface Channel {
+    channelId: string;
+    title: string;
+    description: string;
+    thumbnail: string;
+}
+
+
+
+export class YoutubeAccountHandler {
+    private account_access_token: string; //user_access_token
+
+    /**
+     * Creates a new YoutubeAccountHandler instance
+     * @param account_access_token - The current access token for YouTube API authentication
+     */
+    constructor(account_access_token: string) {
+        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(): Promise<Channel[]> {
+        const url = `${YOUTUBE_BASE_URL}/youtube/v3/channels`;
+        const params: Record<string, any> = {
+            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: any) => ({
+            channelId: ch.id,
+            title: ch.snippet.title,
+            description: ch.snippet.description,
+            thumbnail: ch.snippet.thumbnails?.default?.url,
+        }))
+
+        return channels;
+    }
+
+  
+}