@memberjunction/actions-bizapps-social 2.111.0 → 2.112.0

package/src/providers/tiktok/tiktok-base.action.ts

@@ -1,6 +1,6 @@
 import { RegisterClass } from '@memberjunction/global';
 import { BaseSocialMediaAction, SocialPost, SocialAnalytics, MediaFile } from '../../base/base-social.action';
-import { LogError, LogStatus } from '@memberjunction/core';
+import { LogError, LogStatus } from '@memberjunction/global';
 import axios, { AxiosInstance, AxiosError } from 'axios';
 import { BaseAction } from '@memberjunction/actions';
 
@@ -8,33 +8,33 @@ import { BaseAction } from '@memberjunction/actions';
  * TikTok video information
  */
 export interface TikTokVideo {
-    id: string;
-    share_url: string;
-    title: string;
-    description: string;
-    duration: number;
-    cover_image_url: string;
-    share_count: number;
-    view_count: number;
-    like_count: number;
-    comment_count: number;
-    create_time: number;
+  id: string;
+  share_url: string;
+  title: string;
+  description: string;
+  duration: number;
+  cover_image_url: string;
+  share_count: number;
+  view_count: number;
+  like_count: number;
+  comment_count: number;
+  create_time: number;
 }
 
 /**
  * TikTok user information
  */
 export interface TikTokUser {
-    open_id: string;
-    union_id: string;
-    avatar_url: string;
-    display_name: string;
-    bio_description: string;
-    profile_deep_link: string;
-    is_verified: boolean;
-    follower_count: number;
-    following_count: number;
-    likes_count: number;
+  open_id: string;
+  union_id: string;
+  avatar_url: string;
+  display_name: string;
+  bio_description: string;
+  profile_deep_link: string;
+  is_verified: boolean;
+  follower_count: number;
+  following_count: number;
+  likes_count: number;
 }
 
 /**
@@ -43,315 +43,300 @@ export interface TikTokUser {
  */
 @RegisterClass(BaseAction, 'TikTokBaseAction')
 export abstract class TikTokBaseAction extends BaseSocialMediaAction {
-    
-    protected get platformName(): string {
-        return 'TikTok';
+  protected get platformName(): string {
+    return 'TikTok';
+  }
+
+  protected get apiBaseUrl(): string {
+    return 'https://open-api.tiktok.com';
+  }
+
+  private axiosInstance: AxiosInstance | null = null;
+
+  /**
+   * Initialize axios instance with interceptors
+   */
+  protected getAxiosInstance(): AxiosInstance {
+    if (!this.axiosInstance) {
+      this.axiosInstance = axios.create({
+        baseURL: this.apiBaseUrl,
+        timeout: 30000,
+        headers: {
+          'Content-Type': 'application/json',
+          Accept: 'application/json',
+        },
+      });
+
+      // Request interceptor for logging
+      this.axiosInstance.interceptors.request.use(
+        (config) => {
+          this.logApiRequest(config.method?.toUpperCase() || 'GET', config.url || '', config.data);
+          return config;
+        },
+        (error) => {
+          LogError(`TikTok API Request Error: ${error.message}`);
+          return Promise.reject(error);
+        }
+      );
+
+      // Response interceptor for logging and error handling
+      this.axiosInstance.interceptors.response.use(
+        (response) => {
+          this.logApiResponse(response.data);
+          return response;
+        },
+        async (error: AxiosError) => {
+          if (error.response?.status === 429) {
+            // Rate limit hit
+            const retryAfter = error.response.headers['retry-after'];
+            await this.handleRateLimit(retryAfter ? parseInt(retryAfter) : undefined);
+
+            // Retry the request
+            return this.axiosInstance?.request(error.config!);
+          }
+
+          LogError(`TikTok API Response Error: ${error.message}`);
+          return Promise.reject(error);
+        }
+      );
     }
-    
-    protected get apiBaseUrl(): string {
-        return 'https://open-api.tiktok.com';
+
+    return this.axiosInstance;
+  }
+
+  /**
+   * Make authenticated TikTok API request
+   */
+  protected async makeTikTokRequest<T>(
+    endpoint: string,
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' = 'GET',
+    data?: any,
+    params?: any
+  ): Promise<T> {
+    const token = this.getAccessToken();
+    if (!token) {
+      throw new Error('No access token available for TikTok');
     }
-    
-    private axiosInstance: AxiosInstance | null = null;
-    
-    /**
-     * Initialize axios instance with interceptors
-     */
-    protected getAxiosInstance(): AxiosInstance {
-        if (!this.axiosInstance) {
-            this.axiosInstance = axios.create({
-                baseURL: this.apiBaseUrl,
-                timeout: 30000,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json'
-                }
-            });
-            
-            // Request interceptor for logging
-            this.axiosInstance.interceptors.request.use(
-                (config) => {
-                    this.logApiRequest(config.method?.toUpperCase() || 'GET', config.url || '', config.data);
-                    return config;
-                },
-                (error) => {
-                    LogError(`TikTok API Request Error: ${error.message}`);
-                    return Promise.reject(error);
-                }
-            );
-            
-            // Response interceptor for logging and error handling
-            this.axiosInstance.interceptors.response.use(
-                (response) => {
-                    this.logApiResponse(response.data);
-                    return response;
-                },
-                async (error: AxiosError) => {
-                    if (error.response?.status === 429) {
-                        // Rate limit hit
-                        const retryAfter = error.response.headers['retry-after'];
-                        await this.handleRateLimit(retryAfter ? parseInt(retryAfter) : undefined);
-                        
-                        // Retry the request
-                        return this.axiosInstance?.request(error.config!);
-                    }
-                    
-                    LogError(`TikTok API Response Error: ${error.message}`);
-                    return Promise.reject(error);
-                }
-            );
+
+    const axios = this.getAxiosInstance();
+
+    try {
+      const response = await axios.request<T>({
+        method,
+        url: endpoint,
+        data,
+        params,
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        if (error.response?.status === 401) {
+          // Token might be expired, try to refresh
+          await this.refreshAccessToken();
+
+          // Retry with new token
+          const newToken = this.getAccessToken();
+          const retryResponse = await axios.request<T>({
+            method,
+            url: endpoint,
+            data,
+            params,
+            headers: {
+              Authorization: `Bearer ${newToken}`,
+            },
+          });
+
+          return retryResponse.data;
         }
-        
-        return this.axiosInstance;
+
+        const errorMessage = error.response?.data?.error?.message || error.message;
+        throw new Error(`TikTok API error: ${errorMessage}`);
+      }
+      throw error;
     }
-    
-    /**
-     * Make authenticated TikTok API request
-     */
-    protected async makeTikTokRequest<T>(
-        endpoint: string,
-        method: 'GET' | 'POST' | 'PUT' | 'DELETE' = 'GET',
-        data?: any,
-        params?: any
-    ): Promise<T> {
-        const token = this.getAccessToken();
-        if (!token) {
-            throw new Error('No access token available for TikTok');
-        }
-        
-        const axios = this.getAxiosInstance();
-        
-        try {
-            const response = await axios.request<T>({
-                method,
-                url: endpoint,
-                data,
-                params,
-                headers: {
-                    'Authorization': `Bearer ${token}`
-                }
-            });
-            
-            return response.data;
-        } catch (error) {
-            if (error instanceof AxiosError) {
-                if (error.response?.status === 401) {
-                    // Token might be expired, try to refresh
-                    await this.refreshAccessToken();
-                    
-                    // Retry with new token
-                    const newToken = this.getAccessToken();
-                    const retryResponse = await axios.request<T>({
-                        method,
-                        url: endpoint,
-                        data,
-                        params,
-                        headers: {
-                            'Authorization': `Bearer ${newToken}`
-                        }
-                    });
-                    
-                    return retryResponse.data;
-                }
-                
-                const errorMessage = error.response?.data?.error?.message || error.message;
-                throw new Error(`TikTok API error: ${errorMessage}`);
-            }
-            throw error;
-        }
+  }
+
+  /**
+   * Refresh TikTok access token
+   */
+  protected async refreshAccessToken(): Promise<void> {
+    const refreshToken = this.getRefreshToken();
+    if (!refreshToken) {
+      throw new Error('No refresh token available for TikTok');
     }
-    
-    /**
-     * Refresh TikTok access token
-     */
-    protected async refreshAccessToken(): Promise<void> {
-        const refreshToken = this.getRefreshToken();
-        if (!refreshToken) {
-            throw new Error('No refresh token available for TikTok');
-        }
-        
-        try {
-            const response = await axios.post(`${this.apiBaseUrl}/oauth/refresh_token/`, {
-                client_key: this.getCustomAttribute(2), // Store client key in CustomAttribute2
-                grant_type: 'refresh_token',
-                refresh_token: refreshToken
-            });
-            
-            const { access_token, refresh_token: newRefreshToken, expires_in } = response.data.data;
-            
-            // Update stored tokens
-            await this.updateStoredTokens(access_token, newRefreshToken, expires_in);
-            
-            LogStatus('TikTok access token refreshed successfully');
-        } catch (error) {
-            LogError(`Failed to refresh TikTok access token: ${error}`);
-            throw new Error('Failed to refresh TikTok access token');
-        }
+
+    try {
+      const response = await axios.post(`${this.apiBaseUrl}/oauth/refresh_token/`, {
+        client_key: this.getCustomAttribute(2), // Store client key in CustomAttribute2
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+      });
+
+      const { access_token, refresh_token: newRefreshToken, expires_in } = response.data.data;
+
+      // Update stored tokens
+      await this.updateStoredTokens(access_token, newRefreshToken, expires_in);
+
+      LogStatus('TikTok access token refreshed successfully');
+    } catch (error) {
+      LogError(`Failed to refresh TikTok access token: ${error}`);
+      throw new Error('Failed to refresh TikTok access token');
     }
-    
-    /**
-     * Upload media to TikTok (requires special approval)
-     */
-    protected async uploadSingleMedia(file: MediaFile): Promise<string> {
-        // TikTok video upload requires special approval
-        // This is a placeholder implementation
-        throw new Error('TikTok video upload requires special API approval. Please use TikTok Creator Studio for video uploads.');
+  }
+
+  /**
+   * Upload media to TikTok (requires special approval)
+   */
+  protected async uploadSingleMedia(file: MediaFile): Promise<string> {
+    // TikTok video upload requires special approval
+    // This is a placeholder implementation
+    throw new Error('TikTok video upload requires special API approval. Please use TikTok Creator Studio for video uploads.');
+  }
+
+  /**
+   * Search posts (videos) - TikTok only allows searching user's own videos
+   */
+  protected async searchPosts(params: any): Promise<SocialPost[]> {
+    // TikTok doesn't provide a general search API for security/privacy reasons
+    // We can only search within a user's own videos
+    const videos = await this.getUserVideos();
+
+    let filtered = videos;
+
+    // Apply filters if provided
+    if (params.query) {
+      const query = params.query.toLowerCase();
+      filtered = filtered.filter((video) => video.title.toLowerCase().includes(query) || video.description.toLowerCase().includes(query));
     }
-    
-    /**
-     * Search posts (videos) - TikTok only allows searching user's own videos
-     */
-    protected async searchPosts(params: any): Promise<SocialPost[]> {
-        // TikTok doesn't provide a general search API for security/privacy reasons
-        // We can only search within a user's own videos
-        const videos = await this.getUserVideos();
-        
-        let filtered = videos;
-        
-        // Apply filters if provided
-        if (params.query) {
-            const query = params.query.toLowerCase();
-            filtered = filtered.filter(video => 
-                video.title.toLowerCase().includes(query) ||
-                video.description.toLowerCase().includes(query)
-            );
-        }
-        
-        if (params.hashtags && params.hashtags.length > 0) {
-            filtered = filtered.filter(video => {
-                const videoHashtags = this.extractHashtags(video.description);
-                return params.hashtags.some((tag: string) => 
-                    videoHashtags.includes(tag.toLowerCase())
-                );
-            });
-        }
-        
-        if (params.startDate) {
-            const startTime = new Date(params.startDate).getTime() / 1000;
-            filtered = filtered.filter(video => video.create_time >= startTime);
-        }
-        
-        if (params.endDate) {
-            const endTime = new Date(params.endDate).getTime() / 1000;
-            filtered = filtered.filter(video => video.create_time <= endTime);
-        }
-        
-        // Apply limit and offset
-        if (params.offset) {
-            filtered = filtered.slice(params.offset);
-        }
-        
-        if (params.limit) {
-            filtered = filtered.slice(0, params.limit);
-        }
-        
-        return filtered.map(video => this.normalizePost(video));
+
+    if (params.hashtags && params.hashtags.length > 0) {
+      filtered = filtered.filter((video) => {
+        const videoHashtags = this.extractHashtags(video.description);
+        return params.hashtags.some((tag: string) => videoHashtags.includes(tag.toLowerCase()));
+      });
     }
-    
-    /**
-     * Get user's videos
-     */
-    protected async getUserVideos(): Promise<TikTokVideo[]> {
-        const response = await this.makeTikTokRequest<any>(
-            '/v2/video/list/',
-            'GET',
-            undefined,
-            {
-                fields: 'id,share_url,title,description,duration,cover_image_url,share_count,view_count,like_count,comment_count,create_time'
-            }
-        );
-        
-        return response.data?.videos || [];
+
+    if (params.startDate) {
+      const startTime = new Date(params.startDate).getTime() / 1000;
+      filtered = filtered.filter((video) => video.create_time >= startTime);
     }
-    
-    /**
-     * Convert TikTok video to common post format
-     */
-    protected normalizePost(video: TikTokVideo): SocialPost {
-        return {
-            id: video.id,
-            platform: this.platformName,
-            profileId: this.getCustomAttribute(1) || '', // Store user ID in CustomAttribute1
-            content: video.description || video.title,
-            mediaUrls: [video.cover_image_url],
-            publishedAt: new Date(video.create_time * 1000),
-            analytics: {
-                impressions: video.view_count,
-                engagements: video.like_count + video.comment_count + video.share_count,
-                clicks: 0, // Not available in TikTok API
-                shares: video.share_count,
-                comments: video.comment_count,
-                likes: video.like_count,
-                reach: video.view_count,
-                videoViews: video.view_count,
-                platformMetrics: {
-                    duration: video.duration,
-                    shareUrl: video.share_url
-                }
-            },
-            platformSpecificData: {
-                ...video,
-                videoUrl: video.share_url
-            }
-        };
+
+    if (params.endDate) {
+      const endTime = new Date(params.endDate).getTime() / 1000;
+      filtered = filtered.filter((video) => video.create_time <= endTime);
     }
-    
-    /**
-     * Normalize TikTok analytics to common format
-     */
-    protected normalizeAnalytics(platformData: any): SocialAnalytics {
-        return {
-            impressions: platformData.view_count || 0,
-            engagements: (platformData.like_count || 0) + (platformData.comment_count || 0) + (platformData.share_count || 0),
-            clicks: 0, // Not available in TikTok API
-            shares: platformData.share_count || 0,
-            comments: platformData.comment_count || 0,
-            likes: platformData.like_count || 0,
-            reach: platformData.view_count || 0,
-            videoViews: platformData.view_count || 0,
-            platformMetrics: platformData
-        };
+
+    // Apply limit and offset
+    if (params.offset) {
+      filtered = filtered.slice(params.offset);
     }
-    
-    /**
-     * Extract hashtags from video description
-     */
-    protected extractHashtags(description: string): string[] {
-        const hashtagRegex = /#(\w+)/g;
-        const matches = description.match(hashtagRegex) || [];
-        return matches.map(tag => tag.substring(1).toLowerCase());
+
+    if (params.limit) {
+      filtered = filtered.slice(0, params.limit);
     }
-    
-    /**
-     * Get current user info
-     */
-    protected async getCurrentUser(): Promise<TikTokUser> {
-        const response = await this.makeTikTokRequest<any>(
-            '/v2/user/info/',
-            'GET',
-            undefined,
-            {
-                fields: 'open_id,union_id,avatar_url,display_name,bio_description,profile_deep_link,is_verified,follower_count,following_count,likes_count'
-            }
-        );
-        
-        return response.data?.user;
+
+    return filtered.map((video) => this.normalizePost(video));
+  }
+
+  /**
+   * Get user's videos
+   */
+  protected async getUserVideos(): Promise<TikTokVideo[]> {
+    const response = await this.makeTikTokRequest<any>('/v2/video/list/', 'GET', undefined, {
+      fields: 'id,share_url,title,description,duration,cover_image_url,share_count,view_count,like_count,comment_count,create_time',
+    });
+
+    return response.data?.videos || [];
+  }
+
+  /**
+   * Convert TikTok video to common post format
+   */
+  protected normalizePost(video: TikTokVideo): SocialPost {
+    return {
+      id: video.id,
+      platform: this.platformName,
+      profileId: this.getCustomAttribute(1) || '', // Store user ID in CustomAttribute1
+      content: video.description || video.title,
+      mediaUrls: [video.cover_image_url],
+      publishedAt: new Date(video.create_time * 1000),
+      analytics: {
+        impressions: video.view_count,
+        engagements: video.like_count + video.comment_count + video.share_count,
+        clicks: 0, // Not available in TikTok API
+        shares: video.share_count,
+        comments: video.comment_count,
+        likes: video.like_count,
+        reach: video.view_count,
+        videoViews: video.view_count,
+        platformMetrics: {
+          duration: video.duration,
+          shareUrl: video.share_url,
+        },
+      },
+      platformSpecificData: {
+        ...video,
+        videoUrl: video.share_url,
+      },
+    };
+  }
+
+  /**
+   * Normalize TikTok analytics to common format
+   */
+  protected normalizeAnalytics(platformData: any): SocialAnalytics {
+    return {
+      impressions: platformData.view_count || 0,
+      engagements: (platformData.like_count || 0) + (platformData.comment_count || 0) + (platformData.share_count || 0),
+      clicks: 0, // Not available in TikTok API
+      shares: platformData.share_count || 0,
+      comments: platformData.comment_count || 0,
+      likes: platformData.like_count || 0,
+      reach: platformData.view_count || 0,
+      videoViews: platformData.view_count || 0,
+      platformMetrics: platformData,
+    };
+  }
+
+  /**
+   * Extract hashtags from video description
+   */
+  protected extractHashtags(description: string): string[] {
+    const hashtagRegex = /#(\w+)/g;
+    const matches = description.match(hashtagRegex) || [];
+    return matches.map((tag) => tag.substring(1).toLowerCase());
+  }
+
+  /**
+   * Get current user info
+   */
+  protected async getCurrentUser(): Promise<TikTokUser> {
+    const response = await this.makeTikTokRequest<any>('/v2/user/info/', 'GET', undefined, {
+      fields:
+        'open_id,union_id,avatar_url,display_name,bio_description,profile_deep_link,is_verified,follower_count,following_count,likes_count',
+    });
+
+    return response.data?.user;
+  }
+
+  /**
+   * Validate TikTok-specific media requirements
+   */
+  protected validateMediaFile(file: MediaFile): void {
+    const allowedTypes = ['video/mp4', 'video/quicktime', 'video/webm'];
+
+    if (!allowedTypes.includes(file.mimeType)) {
+      throw new Error(`TikTok only supports video files. Got: ${file.mimeType}`);
     }
-    
-    /**
-     * Validate TikTok-specific media requirements
-     */
-    protected validateMediaFile(file: MediaFile): void {
-        const allowedTypes = ['video/mp4', 'video/quicktime', 'video/webm'];
-        
-        if (!allowedTypes.includes(file.mimeType)) {
-            throw new Error(`TikTok only supports video files. Got: ${file.mimeType}`);
-        }
-        
-        // Max file size: 287.6 MB
-        const maxSize = 287.6 * 1024 * 1024;
-        if (file.size > maxSize) {
-            throw new Error(`File size exceeds TikTok limit of 287.6 MB. Got: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
-        }
+
+    // Max file size: 287.6 MB
+    const maxSize = 287.6 * 1024 * 1024;
+    if (file.size > maxSize) {
+      throw new Error(`File size exceeds TikTok limit of 287.6 MB. Got: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
     }
-}
+  }
+}