@olastudio/social-media-sdk 0.1.0

package/dist/chunk-QZHJXRRW.mjs

@@ -0,0 +1,661 @@
+import { HttpClient, FACEBOOK_GRAPH_API_BASE_URL, FACEBOOK_OAUTH_AUTHORIZATION_URL, FACEBOOK_GRAPH_API_VERSION, METRIC_PRESETS, INSTAGRAM_MEDIA_METRICS_COMMON, INSTAGRAM_STORIES_METRICS, INSTAGRAM_REELS_METRICS } from './chunk-H5GAC4UG.mjs';
+import { AuthError, APIError } from './chunk-36RADUUO.mjs';
+
+// providers/instagram/auth/InstagramAuth.ts
+var InstagramAuth = class {
+  constructor(config) {
+    this.config = config;
+    this.httpClient = new HttpClient({
+      baseURL: FACEBOOK_GRAPH_API_BASE_URL
+    });
+  }
+  /**
+   * Exchange Instagram/Facebook token for session
+   */
+  async exchangeToken(instagramToken) {
+    try {
+      const profile = await this.getProfile(instagramToken);
+      return {
+        accessToken: instagramToken,
+        user: profile
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to exchange Instagram token: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "TOKEN_EXCHANGE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram user profile
+   * First gets Facebook profile, then Instagram Business profile
+   */
+  async getProfile(accessToken) {
+    try {
+      const response = await this.httpClient.get("/me/accounts", {
+        fields: "instagram_business_account",
+        access_token: accessToken
+      });
+      if (!response.data || response.data.length === 0) {
+        throw new AuthError(
+          "No Instagram business account found",
+          "NO_INSTAGRAM_ACCOUNT"
+        );
+      }
+      const instagramAccountId = response.data[0]?.instagram_business_account?.id;
+      if (!instagramAccountId) {
+        throw new AuthError(
+          "No Instagram business account ID found",
+          "NO_INSTAGRAM_ACCOUNT_ID"
+        );
+      }
+      const profile = await this.httpClient.get(
+        `/${instagramAccountId}`,
+        {
+          fields: "id,username,name,account_type,profile_picture_url",
+          access_token: accessToken
+        }
+      );
+      return {
+        id: profile.id,
+        name: profile.name || profile.username,
+        username: profile.username,
+        picture: profile.profile_picture_url
+      };
+    } catch (error) {
+      throw new AuthError(
+        `Failed to fetch Instagram profile: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PROFILE_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get OAuth configuration for Instagram
+   * Instagram uses the same OAuth flow as 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/instagram/api/InstagramAPI.ts
+var InstagramAPI = 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;
+  }
+  // ============= Instagram-specific methods =============
+  /**
+   * Get user's Instagram Business account (single account from first page)
+   */
+  async getAccount(pageAccessToken) {
+    try {
+      const token = pageAccessToken || this.accessToken;
+      if (!token) {
+        throw new APIError("Access token is required", 401, "NO_TOKEN");
+      }
+      const response = await this.get("/me/accounts", {
+        fields: "instagram_business_account",
+        access_token: token
+      });
+      if (!response.data || response.data.length === 0) {
+        throw new APIError(
+          "No Instagram business account found",
+          404,
+          "NO_INSTAGRAM_ACCOUNT"
+        );
+      }
+      const instagramAccountId = response.data[0]?.instagram_business_account?.id;
+      if (!instagramAccountId) {
+        throw new APIError(
+          "No Instagram business account ID found",
+          404,
+          "NO_INSTAGRAM_ACCOUNT_ID"
+        );
+      }
+      const account = await this.get(
+        `/${instagramAccountId}`,
+        {
+          fields: "id,username,name,profile_picture_url,followers_count,follows_count,media_count",
+          access_token: token
+        }
+      );
+      return account;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram account: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNT_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get all Instagram Business accounts linked to user's Facebook pages
+   * Returns all Instagram accounts from all connected Facebook pages
+   */
+  async getInstagramAccounts(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,instagram_business_account{id,username,name,profile_picture_url,followers_count,follows_count,media_count}",
+        access_token: token
+      });
+      if (!response.data || response.data.length === 0) {
+        console.log("   \u2139\uFE0F No Facebook pages found");
+        return [];
+      }
+      const instagramAccounts = [];
+      for (const page of response.data) {
+        if (page.instagram_business_account) {
+          instagramAccounts.push({
+            id: page.instagram_business_account.id,
+            username: page.instagram_business_account.username,
+            name: page.instagram_business_account.name,
+            profile_picture_url: page.instagram_business_account.profile_picture_url,
+            followers_count: page.instagram_business_account.followers_count,
+            follows_count: page.instagram_business_account.follows_count,
+            media_count: page.instagram_business_account.media_count
+          });
+        }
+      }
+      console.log(`   \u2705 Found ${instagramAccounts.length} Instagram account(s)`);
+      return instagramAccounts;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram accounts: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram media
+   */
+  async getMedia(instagramAccountId, limit = 25) {
+    try {
+      const response = await this.get(
+        `/${instagramAccountId}/media`,
+        {
+          fields: "id,media_type,media_url,thumbnail_url,permalink,caption,timestamp,like_count,comments_count",
+          limit
+        }
+      );
+      return response.data;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch Instagram media: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish photo to Instagram (2-step process)
+   */
+  async publishPhoto(params) {
+    const { instagramAccountId, imageUrl, caption } = params;
+    if (!imageUrl) {
+      throw new APIError(
+        "Image URL is required for photo posts",
+        400,
+        "INVALID_PARAMS"
+      );
+    }
+    try {
+      const containerResponse = await this.post(
+        `/${instagramAccountId}/media`,
+        {
+          image_url: imageUrl,
+          caption: caption || ""
+        }
+      );
+      const publishResponse = await this.post(
+        `/${instagramAccountId}/media_publish`,
+        {
+          creation_id: containerResponse.id
+        }
+      );
+      return publishResponse;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish photo: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "PHOTO_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Publish video to Instagram (2-step process)
+   */
+  async publishVideo(params) {
+    const { instagramAccountId, videoUrl, caption } = params;
+    if (!videoUrl) {
+      throw new APIError(
+        "Video URL is required for video posts",
+        400,
+        "INVALID_PARAMS"
+      );
+    }
+    try {
+      const containerResponse = await this.post(
+        `/${instagramAccountId}/media`,
+        {
+          media_type: "VIDEO",
+          video_url: videoUrl,
+          caption: caption || ""
+        }
+      );
+      const publishResponse = await this.post(
+        `/${instagramAccountId}/media_publish`,
+        {
+          creation_id: containerResponse.id
+        }
+      );
+      return publishResponse;
+    } catch (error) {
+      throw new APIError(
+        `Failed to publish video: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "VIDEO_PUBLISH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Delete Instagram media
+   */
+  async deleteMedia(mediaId) {
+    try {
+      const response = await this.delete(
+        `/${mediaId}`
+      );
+      return response.success === true;
+    } catch (error) {
+      throw new APIError(
+        `Failed to delete media: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_DELETE_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get Instagram account insights
+   */
+  async getAccountInsights(instagramAccountId, params) {
+    try {
+      const { metric, period, metric_type, since, until } = params;
+      const response = await this.get(
+        `/${instagramAccountId}/insights`,
+        {
+          metric: metric.join(","),
+          period: period || "day",
+          metric_type: metric_type || "total_value",
+          ...since && { since },
+          ...until && { until }
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "INSIGHTS_FETCH_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get specific media insights
+   */
+  async getMediaInsights(mediaId, metrics) {
+    try {
+      const response = await this.get(
+        `/${mediaId}/insights`,
+        {
+          metric: metrics.join(",")
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch media insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_INSIGHTS_ERROR",
+        error
+      );
+    }
+  }
+  // ============= Enhanced Insights Methods =============
+  /**
+   * Get account insights with default metrics
+   * Uses updated metrics (views instead of impressions)
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Account insights
+   */
+  async getAccountInsightsOverview(instagramAccountId, period = "days_28") {
+    return this.getAccountInsights(instagramAccountId, {
+      metric: [...METRIC_PRESETS.INSTAGRAM_OVERVIEW],
+      period,
+      metric_type: "total_value"
+    });
+  }
+  /**
+   * Get account summary with parsed values
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Parsed account summary
+   */
+  async getAccountSummary(instagramAccountId, period = "days_28") {
+    try {
+      const account = await this.get(`/${instagramAccountId}`, {
+        fields: "id,username,followers_count"
+      });
+      const insights = await this.getAccountInsightsOverview(instagramAccountId, period);
+      const summary = {
+        id: account.id,
+        username: account.username,
+        followers_count: account.followers_count || 0
+      };
+      for (const item of insights.data) {
+        const value = item.total_value?.value ?? item.values?.[0]?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "views":
+            summary.views = value;
+            break;
+          case "reach":
+            summary.reach = value;
+            break;
+          case "accounts_engaged":
+            summary.accounts_engaged = value;
+            break;
+          case "total_interactions":
+            summary.total_interactions = value;
+            break;
+        }
+      }
+      return summary;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch account summary: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "ACCOUNT_SUMMARY_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get media insights based on media type
+   * Automatically selects appropriate metrics
+   * @param mediaId - Media ID
+   * @param mediaType - Type of media
+   * @returns Media insights
+   */
+  async getMediaInsightsByType(mediaId, mediaType) {
+    let metrics;
+    switch (mediaType) {
+      case "REELS":
+        metrics = INSTAGRAM_REELS_METRICS;
+        break;
+      case "VIDEO":
+        metrics = [...INSTAGRAM_MEDIA_METRICS_COMMON, "plays"];
+        break;
+      default:
+        metrics = INSTAGRAM_MEDIA_METRICS_COMMON;
+    }
+    return this.getMediaInsights(mediaId, [...metrics]);
+  }
+  /**
+   * Get media insights with parsed values
+   * @param mediaId - Media ID
+   * @param mediaType - Type of media
+   * @returns Parsed media insights
+   */
+  async getMediaInsightsParsed(mediaId, mediaType = "IMAGE") {
+    try {
+      const response = await this.getMediaInsightsByType(mediaId, mediaType);
+      const insights = {
+        id: mediaId,
+        media_type: mediaType
+      };
+      for (const item of response.data) {
+        const value = item.total_value?.value ?? item.values?.[0]?.value;
+        if (typeof value !== "number") continue;
+        switch (item.name) {
+          case "views":
+            insights.views = value;
+            break;
+          case "reach":
+            insights.reach = value;
+            break;
+          case "likes":
+            insights.likes = value;
+            break;
+          case "comments":
+            insights.comments = value;
+            break;
+          case "shares":
+            insights.shares = value;
+            break;
+          case "saved":
+            insights.saves = value;
+            break;
+          case "plays":
+            insights.plays = value;
+            break;
+          case "total_interactions":
+            insights.total_interactions = value;
+            break;
+        }
+      }
+      return insights;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch parsed media insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "MEDIA_INSIGHTS_PARSED_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get story insights
+   * @param storyId - Story media ID
+   * @returns Story insights
+   */
+  async getStoryInsights(storyId) {
+    return this.getMediaInsights(storyId, [...INSTAGRAM_STORIES_METRICS]);
+  }
+  /**
+   * Get reels insights
+   * @param reelId - Reel media ID
+   * @returns Reel insights
+   */
+  async getReelInsights(reelId) {
+    return this.getMediaInsights(reelId, [...INSTAGRAM_REELS_METRICS]);
+  }
+  /**
+   * Get engagement metrics for account
+   * @param instagramAccountId - Instagram Account ID
+   * @param period - Period for metrics
+   * @returns Engagement insights
+   */
+  async getEngagementInsights(instagramAccountId, period = "days_28") {
+    return this.getAccountInsights(instagramAccountId, {
+      metric: [...METRIC_PRESETS.INSTAGRAM_ENGAGEMENT],
+      period,
+      metric_type: "total_value"
+    });
+  }
+  /**
+   * Get demographics insights for account
+   * @param instagramAccountId - Instagram Account ID
+   * @param breakdown - Demographic breakdown type
+   * @returns Demographics insights
+   */
+  async getDemographicsInsights(instagramAccountId, breakdown = "country") {
+    try {
+      const response = await this.get(
+        `/${instagramAccountId}/insights`,
+        {
+          metric: "follower_demographics",
+          period: "lifetime",
+          metric_type: "total_value",
+          breakdown
+        }
+      );
+      return response;
+    } catch (error) {
+      throw new APIError(
+        `Failed to fetch demographics insights: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        "DEMOGRAPHICS_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Get current API version (read-only)
+   */
+  getApiVersion() {
+    return FACEBOOK_GRAPH_API_VERSION;
+  }
+};
+
+// providers/instagram/InstagramProvider.ts
+var InstagramProvider = class {
+  constructor(config) {
+    this.name = "instagram";
+    this.config = config;
+    this.auth = new InstagramAuth(config);
+    this.api = new InstagramAPI(config);
+  }
+  /**
+   * Create new API instance with access token
+   */
+  createAPIClient(accessToken) {
+    return new InstagramAPI(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/instagram/types/index.ts
+var InstagramScopes = /* @__PURE__ */ ((InstagramScopes2) => {
+  InstagramScopes2["BASIC"] = "instagram_basic";
+  InstagramScopes2["CONTENT_PUBLISH"] = "instagram_content_publish";
+  InstagramScopes2["MANAGE_COMMENTS"] = "instagram_manage_comments";
+  InstagramScopes2["MANAGE_INSIGHTS"] = "instagram_manage_insights";
+  InstagramScopes2["MANAGE_MESSAGES"] = "instagram_manage_messages";
+  InstagramScopes2["SHOPPING_TAG_PRODUCTS"] = "instagram_shopping_tag_products";
+  return InstagramScopes2;
+})(InstagramScopes || {});
+
+export { InstagramAPI, InstagramAuth, InstagramProvider, InstagramScopes };
+//# sourceMappingURL=chunk-QZHJXRRW.mjs.map
+//# sourceMappingURL=chunk-QZHJXRRW.mjs.map