@olastudio/social-media-sdk 0.1.0 → 0.1.2

package/dist/providers/facebook/index.js

@@ -1,30 +1,1075 @@
 'use strict';
 
-var chunkPJ4KYVHH_js = require('../../chunk-PJ4KYVHH.js');
-require('../../chunk-ER5A6TIL.js');
-require('../../chunk-HPLIHYLQ.js');
-
-
-
-Object.defineProperty(exports, "FacebookAPI", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookAPI; }
-});
-Object.defineProperty(exports, "FacebookAuth", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookAuth; }
-});
-Object.defineProperty(exports, "FacebookProvider", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookProvider; }
-});
-Object.defineProperty(exports, "FacebookScopesBusiness", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookScopesBusiness; }
-});
-Object.defineProperty(exports, "FacebookScopesUser", {
-  enumerable: true,
-  get: function () { return chunkPJ4KYVHH_js.FacebookScopesUser; }
-});
+// core/constants.ts
+var FACEBOOK_GRAPH_API_VERSION = "v24.0";
+var FACEBOOK_GRAPH_API_BASE_URL = `https://graph.facebook.com/${FACEBOOK_GRAPH_API_VERSION}`;
+var FACEBOOK_OAUTH_AUTHORIZATION_URL = `https://www.facebook.com/${FACEBOOK_GRAPH_API_VERSION}/dialog/oauth`;
+
+// core/errors/BaseError.ts
+var BaseError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+
+// core/errors/AuthError.ts
+var AuthError = class extends BaseError {
+  constructor(message, code, details) {
+    super(message, code, details);
+    this.name = "AuthError";
+  }
+};
+
+// core/errors/APIError.ts
+var APIError = class extends BaseError {
+  constructor(message, statusCode, code, details) {
+    super(message, code, details);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+  }
+};
+
+// core/http/HttpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      // 30 seconds default
+      headers: {
+        "Content-Type": "application/json"
+      },
+      ...config
+    };
+  }
+  /**
+   * Generic request
+   */
+  async request(endpoint, options = {}) {
+    const url = this.buildURL(endpoint, options.params);
+    const method = options.method || "GET";
+    const headers = {
+      ...this.config.headers,
+      ...options.headers
+    };
+    if (this.config.accessToken) {
+      headers["Authorization"] = `Bearer ${this.config.accessToken}`;
+    }
+    const config = {
+      method,
+      headers,
+      signal: this.createAbortSignal(options.timeout || this.config.timeout)
+    };
+    if (options.body && method !== "GET") {
+      if (headers["Content-Type"] === "application/json") {
+        config.body = JSON.stringify(options.body);
+      } else if (headers["Content-Type"] === "application/x-www-form-urlencoded") {
+        config.body = this.encodeFormBody(options.body);
+      } else {
+        config.body = options.body;
+      }
+    }
+    try {
+      const response = await fetch(url, config);
+      return await this.handleResponse(response);
+    } catch (error) {
+      if (error instanceof APIError) {
+        throw error;
+      }
+      throw new APIError(
+        `Network error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        "NETWORK_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Build URL with query params
+   */
+  buildURL(endpoint, params) {
+    const url = endpoint.startsWith("http") ? endpoint : `${this.config.baseURL}${endpoint}`;
+    if (!params || Object.keys(params).length === 0) {
+      return url;
+    }
+    const queryString = Object.entries(params).filter(([_, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  /**
+   * Encode body as form-urlencoded
+   */
+  encodeFormBody(body) {
+    return Object.entries(body).filter(([_, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+  }
+  /**
+   * Create AbortSignal for timeout
+   */
+  createAbortSignal(timeout) {
+    if (!timeout) return void 0;
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), timeout);
+    return controller.signal;
+  }
+  /**
+   * Handle HTTP response
+   */
+  async handleResponse(response) {
+    let data;
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      data = await response.json();
+    } else {
+      data = await response.text();
+    }
+    if (!response.ok) {
+      const errorMessage = data?.error?.message || data?.message || "API request failed";
+      const errorCode = data?.error?.code || data?.code || response.status;
+      throw new APIError(errorMessage, response.status, errorCode, data);
+    }
+    return data;
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(token) {
+    this.config.accessToken = token;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// core/insights.constants.ts
+var POST_METRICS = [
+  "post_engaged_users",
+  "post_negative_feedback",
+  "post_engaged_fan",
+  "post_clicks",
+  "post_clicks_unique",
+  "post_reactions_by_type_total"
+];
+var VIDEO_METRICS = [
+  "total_video_views",
+  "total_video_views_unique",
+  "total_video_views_autoplayed",
+  "total_video_views_clicked_to_play",
+  "total_video_views_organic",
+  "total_video_views_organic_unique",
+  "total_video_views_paid",
+  "total_video_views_paid_unique",
+  "total_video_avg_time_watched",
+  "total_video_view_total_time",
+  "total_video_complete_views",
+  "total_video_complete_views_unique",
+  "total_video_complete_views_organic",
+  "total_video_complete_views_organic_unique",
+  "total_video_complete_views_paid",
+  "total_video_complete_views_paid_unique"
+];
+var REELS_METRICS = [
+  "blue_reels_play_count",
+  "post_video_avg_time_watched",
+  "post_video_views",
+  "post_video_social_actions"
+];
+var PHOTO_METRICS = [
+  "photo_views",
+  "photo_reach",
+  "engaged_users"
+];
+var METRIC_PRESETS = {
+  // Facebook Page quick overview
+  PAGE_OVERVIEW: ["page_views_total", "page_post_engagements", "page_video_views"],
+  // Facebook Video performance
+  VIDEO_PERFORMANCE: ["total_video_views", "total_video_avg_time_watched", "total_video_complete_views"],
+  // Facebook Reels performance
+  REELS_PERFORMANCE: ["blue_reels_play_count", "post_video_avg_time_watched", "post_video_social_actions"],
+  // Instagram account overview
+  INSTAGRAM_OVERVIEW: ["views", "reach", "accounts_engaged", "total_interactions"],
+  // Instagram content engagement
+  INSTAGRAM_ENGAGEMENT: ["likes", "comments", "shares", "saves"]
+};
+
+// providers/facebook/api/FacebookAPI.ts
+var FacebookAPI = class {
+  constructor(config, accessToken) {
+    this.config = config;
+    this.accessToken = accessToken;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL,
+      accessToken: this.accessToken
+    });
+  }
+  /**
+   * Generic request
+   */
+  async request(endpoint, options = {}) {
+    if (this.accessToken && !options.params?.access_token) {
+      options.params = {
+        ...options.params,
+        access_token: this.accessToken
+      };
+    }
+    return this.httpClient.request(endpoint, options);
+  }
+  /**
+   * GET request
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST request
+   */
+  async post(endpoint, body) {
+    return this.request(endpoint, { method: "POST", body });
+  }
+  /**
+   * PUT request
+   */
+  async put(endpoint, body) {
+    return this.request(endpoint, { method: "PUT", body });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * Update access token
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.httpClient.setAccessToken(token);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  // ============= Facebook-specific methods =============
+  /**
+   * Get user's pages
+   */
+  async getPages(userAccessToken) {
+    try {
+      const token = userAccessToken || this.accessToken;
+      if (!token) {
+        throw new APIError("Access token is required", 401, "NO_TOKEN");
+      }
+      const response = await this.get("/me/accounts", {
+        fields: "id,name,access_token,picture",
+        access_token: token
+      });
+      return response.data;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Facebook pages: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGES_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish post to Facebook page
+   */
+  async publishPost(params) {
+    const { pageId, pageAccessToken, message, imageUrl, scheduledPublishTime } = params;
+    try {
+      let endpoint = `/${pageId}/`;
+      const body = {
+        access_token: pageAccessToken
+      };
+      if (scheduledPublishTime) {
+        body.published = false;
+        body.scheduled_publish_time = scheduledPublishTime;
+      }
+      if (imageUrl) {
+        endpoint += "photos";
+        body.url = imageUrl;
+        if (message) body.caption = message;
+      } else if (message) {
+        endpoint += "feed";
+        body.message = message;
+      } else {
+        throw new APIError(
+          "Either message or imageUrl must be provided",
+          400,
+          "INVALID_PARAMS"
+        );
+      }
+      const response = await this.request(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish post: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Delete Facebook post
+   */
+  async deletePost(postId, pageAccessToken) {
+    try {
+      const response = await this.delete(
+        `/${postId}?access_token=${pageAccessToken}`
+      );
+      return response.success === true;
+    } catch (error) {
+      throw new APIError(
+        `Failed to delete post: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_DELETE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page information
+   */
+  async getPage(pageId, fields) {
+    try {
+      const fieldsParam = fields?.join(",") || "id,name,access_token,picture";
+      return await this.get(`/${pageId}`, {
+        fields: fieldsParam
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Debug/validate a Facebook access token
+   * Uses Facebook's debug_token endpoint
+   *
+   * @param inputToken - The token to validate
+   * @param appAccessToken - App token (app_id|app_secret)
+   * @returns Token debug information
+   */
+  async debugToken(inputToken, appAccessToken) {
+    try {
+      return await this.get("/debug_token", {
+        input_token: inputToken,
+        access_token: appAccessToken
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to debug token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "TOKEN_DEBUG_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page insights/analytics
+   * @param pageId - Facebook Page ID
+   * @param options - Insights options
+   * @returns Page insights data
+   */
+  async getPageInsights(pageId, options) {
+    try {
+      const params = {
+        metric: options.metric.join(","),
+        period: options.period || "day"
+      };
+      if (options.since) params.since = options.since;
+      if (options.until) params.until = options.until;
+      const response = await this.get(`/${pageId}/insights`, params);
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "INSIGHTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page fans count (total followers)
+   * @param pageId - Facebook Page ID
+   * @returns Page with fan count
+   */
+  async getPageFansCount(pageId) {
+    try {
+      return await this.get(`/${pageId}`, {
+        fields: "id,fan_count"
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page fans count: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "FANS_COUNT_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page overview with key metrics
+   * @param pageId - Facebook Page ID
+   * @returns Page overview data
+   */
+  async getPageOverview(pageId) {
+    try {
+      const response = await this.get(`/${pageId}`, {
+        fields: "id,name,followers_count,fan_count"
+      });
+      return {
+        id: response.id,
+        name: response.name,
+        followers_count: response.followers_count || response.fan_count || 0,
+        fan_count: response.fan_count
+      };
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page overview: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_OVERVIEW_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Video Insights Methods =============
+  /**
+   * Get video insights
+   * @param videoId - Facebook Video ID
+   * @param metrics - Specific metrics to fetch (defaults to common metrics)
+   * @returns Video insights data
+   */
+  async getVideoInsights(videoId, metrics) {
+    try {
+      const metricsToFetch = metrics || METRIC_PRESETS.VIDEO_PERFORMANCE;
+      const response = await this.get(
+        `/${videoId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch video insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get video insights with parsed values
+   * @param videoId - Facebook Video ID
+   * @returns Parsed video insights
+   */
+  async getVideoInsightsParsed(videoId) {
+    try {
+      const response = await this.getVideoInsights(videoId, [...VIDEO_METRICS.slice(0, 8)]);
+      const insights = { id: videoId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "total_video_views":
+            insights.total_views = value;
+            break;
+          case "total_video_views_unique":
+            insights.unique_views = value;
+            break;
+          case "total_video_avg_time_watched":
+            insights.avg_time_watched = value;
+            break;
+          case "total_video_complete_views":
+            insights.complete_views = value;
+            break;
+          case "total_video_views_organic":
+            insights.organic_views = value;
+            break;
+          case "total_video_views_paid":
+            insights.paid_views = value;
+            break;
+          case "total_video_view_total_time":
+            insights.total_time_watched = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed video insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page videos with basic info
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of videos to fetch
+   * @returns List of videos
+   */
+  async getPageVideos(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/videos`, {
+        fields: "id,title,description,created_time,length",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page videos: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_VIDEOS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Reels Insights Methods =============
+  /**
+   * Get reels insights
+   * @param reelId - Facebook Reel ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Reels insights data
+   */
+  async getReelsInsights(reelId, metrics) {
+    try {
+      const metricsToFetch = metrics || METRIC_PRESETS.REELS_PERFORMANCE;
+      const response = await this.get(
+        `/${reelId}/video_insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch reels insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "REELS_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get reels insights with parsed values
+   * @param reelId - Facebook Reel ID
+   * @returns Parsed reels insights
+   */
+  async getReelsInsightsParsed(reelId) {
+    try {
+      const response = await this.getReelsInsights(reelId, [...REELS_METRICS]);
+      const insights = { id: reelId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "blue_reels_play_count":
+            insights.plays = value;
+            break;
+          case "post_video_avg_time_watched":
+            insights.avg_time_watched = value;
+            break;
+          case "post_video_views":
+            insights.total_plays = value;
+            break;
+        }
+      }
+      try {
+        const postResponse = await this.get(`/${reelId}`, {
+          fields: "reactions.summary(true),comments.summary(true),shares"
+        });
+        insights.likes = postResponse.reactions?.summary?.total_count;
+        insights.comments = postResponse.comments?.summary?.total_count;
+        insights.shares = postResponse.shares?.count;
+      } catch {
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed reels insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "REELS_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page reels
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of reels to fetch
+   * @returns List of reels
+   */
+  async getPageReels(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/video_reels`, {
+        fields: "id,description,created_time",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page reels: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_REELS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Post Insights Methods =============
+  /**
+   * Get post insights
+   * @param postId - Facebook Post ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Post insights data
+   */
+  async getPostInsights(postId, metrics) {
+    try {
+      const metricsToFetch = metrics || [...POST_METRICS];
+      const response = await this.get(
+        `/${postId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch post insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get post insights with parsed values
+   * @param postId - Facebook Post ID
+   * @returns Parsed post insights
+   */
+  async getPostInsightsParsed(postId) {
+    try {
+      const response = await this.getPostInsights(postId);
+      const insights = { id: postId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        switch (item.name) {
+          case "post_engaged_users":
+            if (typeof value === "number") insights.engaged_users = value;
+            break;
+          case "post_clicks":
+            if (typeof value === "number") insights.clicks = value;
+            break;
+          case "post_negative_feedback":
+            if (typeof value === "number") insights.negative_feedback = value;
+            break;
+          case "post_reactions_by_type_total":
+            if (typeof value === "object") insights.reactions_by_type = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed post insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "POST_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page posts/feed
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of posts to fetch
+   * @returns List of posts
+   */
+  async getPagePosts(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/feed`, {
+        fields: "id,message,created_time,type",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page posts: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_POSTS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Photo Insights Methods =============
+  /**
+   * Get photo insights
+   * @param photoId - Facebook Photo ID
+   * @param metrics - Specific metrics to fetch
+   * @returns Photo insights data
+   */
+  async getPhotoInsights(photoId, metrics) {
+    try {
+      const metricsToFetch = metrics || [...PHOTO_METRICS];
+      const response = await this.get(
+        `/${photoId}/insights`,
+        {
+          metric: metricsToFetch.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch photo insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get photo insights with parsed values
+   * @param photoId - Facebook Photo ID
+   * @returns Parsed photo insights
+   */
+  async getPhotoInsightsParsed(photoId) {
+    try {
+      const response = await this.getPhotoInsights(photoId);
+      const insights = { id: photoId };
+      for (const item of response.data) {
+        const value = item.values?.[0]?.value ?? item.total_value?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "photo_views":
+            insights.views = value;
+            break;
+          case "photo_reach":
+            insights.reach = value;
+            break;
+          case "engaged_users":
+            insights.engaged_users = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed photo insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get page photos
+   * @param pageId - Facebook Page ID
+   * @param limit - Number of photos to fetch
+   * @returns List of photos
+   */
+  async getPagePhotos(pageId, limit = 25) {
+    try {
+      return await this.get(`/${pageId}/photos`, {
+        fields: "id,name,created_time",
+        type: "uploaded",
+        limit
+      });
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page photos: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_PHOTOS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Batch/Helper Methods =============
+  /**
+   * Get quick insights summary for a page
+   * Combines key metrics in a single call
+   * @param pageId - Facebook Page ID
+   * @param period - Period for time-based metrics
+   * @returns Summary of page insights
+   */
+  async getPageInsightsSummary(pageId, period = "days_28") {
+    try {
+      const overview = await this.getPageOverview(pageId);
+      const insightsResponse = await this.getPageInsights(pageId, {
+        metric: [...METRIC_PRESETS.PAGE_OVERVIEW],
+        period
+      });
+      const engagement = {};
+      for (const item of insightsResponse.data) {
+        const values = item.values || [];
+        const total = values.reduce((sum, v) => sum + (typeof v.value === "number" ? v.value : 0), 0);
+        switch (item.name) {
+          case "page_views_total":
+            engagement.views = total;
+            break;
+          case "page_post_engagements":
+            engagement.post_engagements = total;
+            break;
+          case "page_video_views":
+            engagement.video_views = total;
+            break;
+        }
+      }
+      return { overview, engagement };
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch page insights summary: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PAGE_SUMMARY_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/facebook/auth/FacebookAuth.ts
+var FacebookAuth = class {
+  constructor(config) {
+    this.config = config;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL
+    });
+  }
+  /**
+   * Exchange Facebook token for session
+   * In Expo + Supabase, this is handled in the app
+   * This function only validates and gets profile info
+   */
+  async exchangeToken(facebookToken) {
+    try {
+      const profile = await this.getProfile(facebookToken);
+      return {
+        accessToken: facebookToken,
+        user: profile
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange Facebook token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "TOKEN_EXCHANGE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Facebook user profile
+   */
+  async getProfile(accessToken) {
+    try {
+      const profile = await this.httpClient.get("/me", {
+        fields: "id,name,email,picture",
+        access_token: accessToken
+      });
+      return {
+        id: profile.id,
+        name: profile.name,
+        email: profile.email,
+        picture: profile.picture?.data?.url
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to fetch Facebook profile: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROFILE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Exchange short-lived token for long-lived token
+   */
+  async exchangeForLongLivedToken(params) {
+    try {
+      const response = await this.httpClient.get(
+        "/oauth/access_token",
+        {
+          grant_type: "fb_exchange_token",
+          client_id: params.appId,
+          client_secret: params.appSecret,
+          fb_exchange_token: params.shortLivedToken
+        }
+      );
+      return response.access_token;
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange for long-lived token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "LONG_LIVED_TOKEN_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get OAuth configuration for Facebook
+   */
+  getOAuthConfig(scopes, redirectUri) {
+    return {
+      authorizationEndpoint: FACEBOOK_OAUTH_AUTHORIZATION_URL,
+      tokenEndpoint: `${FACEBOOK_GRAPH_API_BASE_URL}/oauth/access_token`,
+      clientId: this.config.appId,
+      clientSecret: this.config.appSecret,
+      redirectUri,
+      scopes,
+      responseType: "token",
+      extraParams: {
+        display: "popup"
+      }
+    };
+  }
+  /**
+   * Get authorization URL
+   */
+  getAuthorizationUrl(scopes, redirectUri, state) {
+    const params = new URLSearchParams({
+      client_id: this.config.appId,
+      redirect_uri: redirectUri,
+      scope: scopes.join(","),
+      response_type: "token",
+      display: "popup",
+      ...state && { state }
+    });
+    return `${FACEBOOK_OAUTH_AUTHORIZATION_URL}?${params.toString()}`;
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/facebook/FacebookProvider.ts
+var FacebookProvider = class {
+  constructor(config) {
+    this.name = "facebook";
+    this.config = config;
+    this.auth = new FacebookAuth(config);
+    this.api = new FacebookAPI(config);
+  }
+  /**
+   * Create new API instance with access token
+   */
+  createAPIClient(accessToken) {
+    return new FacebookAPI(this.config, accessToken);
+  }
+  /**
+   * Update access token of existing API client
+   */
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.api.getAccessToken();
+  }
+};
+
+// providers/facebook/types/index.ts
+var FacebookScopesBusiness = /* @__PURE__ */ ((FacebookScopesBusiness2) => {
+  FacebookScopesBusiness2["PUBLIC_PROFILE"] = "public_profile";
+  FacebookScopesBusiness2["EMAIL"] = "email";
+  FacebookScopesBusiness2["PAGES_SHOW_LIST"] = "pages_show_list";
+  FacebookScopesBusiness2["PAGES_READ_ENGAGEMENT"] = "pages_read_engagement";
+  FacebookScopesBusiness2["PAGES_MANAGE_POSTS"] = "pages_manage_posts";
+  FacebookScopesBusiness2["ADS_MANAGEMENT"] = "ads_management";
+  FacebookScopesBusiness2["ADS_READ"] = "ads_read";
+  FacebookScopesBusiness2["BUSINESS_MANAGEMENT"] = "business_management";
+  FacebookScopesBusiness2["CATALOG_MANAGEMENT"] = "catalog_management";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_MANAGE_ORDERS"] = "commerce_account_manage_orders";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_ORDERS"] = "commerce_account_read_orders";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_REPORTS"] = "commerce_account_read_reports";
+  FacebookScopesBusiness2["COMMERCE_ACCOUNT_READ_SETTINGS"] = "commerce_account_read_settings";
+  FacebookScopesBusiness2["COMMERCE_MANAGE_ACCOUNTS"] = "commerce_manage_accounts";
+  FacebookScopesBusiness2["INSTAGRAM_BASIC"] = "instagram_basic";
+  FacebookScopesBusiness2["INSTAGRAM_CONTENT_PUBLISH"] = "instagram_content_publish";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_COMMENTS"] = "instagram_manage_comments";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_INSIGHTS"] = "instagram_manage_insights";
+  FacebookScopesBusiness2["INSTAGRAM_MANAGE_MESSAGES"] = "instagram_manage_messages";
+  FacebookScopesBusiness2["INSTAGRAM_SHOPPING_TAG_PRODUCTS"] = "instagram_shopping_tag_products";
+  FacebookScopesBusiness2["LEADS_RETRIEVAL"] = "leads_retrieval";
+  FacebookScopesBusiness2["MANAGE_APP_SOLUTIONS"] = "manage_app_solutions";
+  FacebookScopesBusiness2["MANAGE_FUNDRAISERS"] = "manage_fundraisers";
+  FacebookScopesBusiness2["PAGES_MANAGE_CTA"] = "pages_manage_cta";
+  FacebookScopesBusiness2["PAGE_EVENTS"] = "page_events";
+  FacebookScopesBusiness2["PAGES_MANAGE_ADS"] = "pages_manage_ads";
+  FacebookScopesBusiness2["PAGES_MANAGE_ENGAGEMENT"] = "pages_manage_engagement";
+  FacebookScopesBusiness2["PAGES_MANAGE_INSTANT_ARTICLES"] = "pages_manage_instant_articles";
+  FacebookScopesBusiness2["PAGES_MANAGE_METADATA"] = "pages_manage_metadata";
+  FacebookScopesBusiness2["PAGES_MESSAGING"] = "pages_messaging";
+  FacebookScopesBusiness2["PAGES_READ_USER_CONTENT"] = "pages_read_user_content";
+  FacebookScopesBusiness2["PRIVATE_COMPUTATION_ACCESS"] = "private_computation_access";
+  FacebookScopesBusiness2["PUBLISH_VIDEO"] = "publish_video";
+  FacebookScopesBusiness2["READ_INSIGHTS"] = "read_insights";
+  FacebookScopesBusiness2["READ_AUDIENCE_NETWORK_INSIGHTS"] = "read_audience_network_insights";
+  FacebookScopesBusiness2["WHATSAPP_BUSINESS_MANAGEMENT"] = "whatsapp_business_management";
+  FacebookScopesBusiness2["WHATSAPP_BUSINESS_MESSAGING"] = "whatsapp_business_messaging";
+  return FacebookScopesBusiness2;
+})(FacebookScopesBusiness || {});
+var FacebookScopesUser = /* @__PURE__ */ ((FacebookScopesUser2) => {
+  FacebookScopesUser2["PUBLIC_PROFILE"] = "public_profile";
+  FacebookScopesUser2["EMAIL"] = "email";
+  FacebookScopesUser2["USER_FRIENDS"] = "user_friends";
+  return FacebookScopesUser2;
+})(FacebookScopesUser || {});
+
+exports.FacebookAPI = FacebookAPI;
+exports.FacebookAuth = FacebookAuth;
+exports.FacebookProvider = FacebookProvider;
+exports.FacebookScopesBusiness = FacebookScopesBusiness;
+exports.FacebookScopesUser = FacebookScopesUser;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map