my-youtube-api 1.0.0

package/dist/error-utils.d.ts

@@ -0,0 +1,16 @@
+export declare const YOUTUBE_BASE_URL = "https://www.googleapis.com";
+export declare const RUPLOAD_URL = "https://rupload.facebook.com";
+export declare 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"
+}
+export declare class FacebookError extends Error {
+    code: FacebookErrorCode;
+    originalError?: any;
+    constructor(code: FacebookErrorCode, originalError?: any);
+}

package/dist/error-utils.js

@@ -0,0 +1,29 @@
+export const YOUTUBE_BASE_URL = "https://www.googleapis.com";
+export const RUPLOAD_URL = 'https://rupload.facebook.com';
+export var FacebookErrorCode;
+(function (FacebookErrorCode) {
+    FacebookErrorCode["NO_ACCOUNT"] = "NO_ACCOUNT";
+    FacebookErrorCode["ACCESS_TOKEN_EXPIRED"] = "ACCESS_TOKEN_EXPIRED";
+    FacebookErrorCode["FAILED_GET_PAGES"] = "FAILED_GET_PAGES";
+    FacebookErrorCode["ACCESS_TOKEN_INVALID"] = "ACCESS_TOKEN_INVALID";
+    FacebookErrorCode["PAGE_NOT_FOUND"] = "PAGE_NOT_FOUND";
+    FacebookErrorCode["PAGE_ACCESS_TOKEN_EXPIRE"] = "PAGE_ACCESS_TOKEN_EXPIRE";
+    FacebookErrorCode["FAILED_FETCH_PAGES_FROM_API"] = "FAILED_FETCH_PAGES_FROM_API";
+})(FacebookErrorCode || (FacebookErrorCode = {}));
+const errorMessages = {
+    [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(code, originalError) {
+        super(errorMessages[code]);
+        this.code = code;
+        this.originalError = originalError;
+        this.name = 'FacebookError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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";
+import { isValidAccessToken, fetchNewAccessToken } from './utils';
+export { YoutubeAccountHandler, YoutubeChannelHandler, YoutubeVideoHandler, YoutubeVideoPoster, isValidAccessToken, fetchNewAccessToken };

package/dist/index.js

@@ -0,0 +1,12 @@
+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/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,40 @@
+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/dist/utils.d.ts

@@ -0,0 +1,27 @@
+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 declare function isValidAccessToken(accessToken: string | null): Promise<boolean>;
+/**
+   * 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 declare function fetchNewAccessToken(valid_refresh_token: string, google_client_id: string, google_client_secret: string): Promise<AccessTokenType>;
+export {};

package/dist/utils.js

@@ -0,0 +1,61 @@
+import axios from "axios";
+/**
+ * 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) {
+    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, google_client_id, google_client_secret) {
+    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) {
+        console.error("❌ Failed to refresh access token:", error.response?.data || error.message);
+        throw error;
+    }
+}

package/dist/youtube-handlers/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-handlers/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;
+    }
+}

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

@@ -0,0 +1,65 @@
+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;
+    currency: string;
+    startDate: string;
+    endDate: string;
+}
+export declare class YoutubeChannelHandler {
+    private access_token;
+    private channel_id;
+    constructor(access_token: string, channel_id: string);
+    /**
+     * Fetches basic channel statistics and information
+     * @returns Channel analytics including subscriber count, view count, and video count
+     */
+    fetchChannelAnalytics(): Promise<ChannelAnalytics>;
+    /**
+     * 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
+     */
+    fetchVideos(maxResults?: number): Promise<VideoAnalytics[]>;
+    /**
+     * Fetches audience analytics and engagement metrics for the channel
+     * @returns Audience analytics including view duration and subscriber changes
+     */
+    fetchAudienceAnalytics(): Promise<AudienceAnalytics>;
+    fetchChannelRevenue(startDate?: string, endDate?: string): Promise<ChannelRevenue>;
+}
+export {};

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

@@ -0,0 +1,193 @@
+import axios from "axios";
+/*
+. 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 {
+    constructor(access_token, channel_id) {
+        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() {
+        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 = 50) {
+        // 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) => 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) => {
+            // 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() {
+        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.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 = 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, row) => ({
+                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 = "2023-01-01", endDate = new Date().toISOString().split("T")[0]) {
+        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, row) => acc + parseFloat(row[1] || 0), 0)
+                : 0;
+            return {
+                estimatedRevenue: totalRevenue,
+                currency: "USD",
+                startDate,
+                endDate
+            };
+        }
+        catch (err) {
+            console.error("Failed to fetch channel revenue:", err.response?.data || err.message);
+            return { estimatedRevenue: 0, currency: "USD", startDate, endDate };
+        }
+    }
+}

package/dist/youtube-handlers/youtube-channel-handler2.d.ts

@@ -0,0 +1,65 @@
+interface GrowthMetrics {
+    subscribers: number;
+    totalVideoViews: number;
+    estimatedRevenue: number;
+    videosCount: number;
+    period: string;
+}
+interface VideoPerformance {
+    videoId: string;
+    title: string;
+    publishedAt: string;
+    views: number;
+    watchTime: number;
+    avgViewDuration: number;
+    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 declare class YoutubeAnalyticsHandler {
+    private access_token;
+    private channel_id;
+    constructor(access_token: string, channel_id: string);
+    /**
+     * 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
+     */
+    fetchGrowthMetrics(period?: string): Promise<GrowthMetrics>;
+    /**
+     * 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
+     */
+    fetchPublishedVideosStats(period?: string): Promise<PublishedVideosStats>;
+    /**
+     * 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
+     */
+    fetchVideosList(maxResults?: number): Promise<VideoPerformance[]>;
+    private fetchChannelBasicStats;
+    private fetchVideosPublishedInPeriod;
+    private fetchVideosDetailedStats;
+    private getStartDate;
+}
+export {};