glitch-javascript-sdk 1.8.0 → 1.8.2

package/src/api/WebsiteAnalytics.ts

@@ -0,0 +1,308 @@
+import WebsiteAnalyticsRoute from "../routes/WebsiteAnalyticsRoute";
+import Requests from "../util/Requests";
+import Response from "../util/Response";
+import { AxiosPromise } from "axios";
+
+class WebsiteAnalytics {
+  /**
+   * List website analytics sessions with comprehensive filtering
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - device_type?: 'desktop'|'mobile'|'tablet'|'bot'|'other'
+   *   - country_code?: string - 2-letter country code
+   *   - is_bot?: boolean - Filter by bot status
+   *   - sort?: 'started_at'|'total_duration'|'pageview_count' - Sort field
+   *   - order?: 'asc'|'desc' - Sort order
+   *   - per_page?: number - Items per page (max 100)
+   * @returns Promise with paginated sessions data
+   */
+  public static listSessions<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.listSessions,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get a paginated list of pageviews with filtering options
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - analytics_session_id?: string - Filter by session ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - is_exit?: boolean - Filter by exit pageviews
+   *   - sort?: 'occurred_at'|'load_time_ms'|'dom_complete_ms' - Sort field
+   *   - order?: 'asc'|'desc' - Sort order
+   *   - per_page?: number - Items per page (max 100)
+   * @returns Promise with paginated pageviews data
+   */
+  public static listPageviews<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.listPageviews,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get a paginated list of events with filtering options
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - analytics_session_id?: string - Filter by session ID
+   *   - event_name?: string - Filter by event name
+   *   - event_category?: string - Filter by event category
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - sort?: 'occurred_at'|'event_name' - Sort field
+   *   - order?: 'asc'|'desc' - Sort order
+   *   - per_page?: number - Items per page (max 100)
+   * @returns Promise with paginated events data
+   */
+  public static listEvents<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.listEvents,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get an analytics overview with summarized metrics
+   * 
+   * @param params Overview options:
+   *   - title_id: string - Required title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - group_by?: 'day'|'week'|'month'|'year' - Grouping period
+   *   - include_breakdowns?: boolean - Include detailed breakdowns
+   * @returns Promise with overview data
+   */
+  public static overview<T>(params: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.overview,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Single ingestion endpoint for sessions, pageviews and events
+   * 
+   * @param data Analytics data payload with type property:
+   *   - type: 'session'|'pageview'|'event' - Type of analytics data
+   *   - title_id: string - Title ID
+   *   - tracking_token: string - HMAC token for verification
+   *   - plus type-specific fields
+   * @returns Promise with acceptance response
+   */
+  public static collect<T>(data: object): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.collect,
+      data
+    );
+  }
+
+  /**
+   * Get average session length data with optional grouping
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - group_by?: 'day'|'week'|'month' - Grouping period
+   *   - device_type?: string - Filter by device type
+   *   - country_code?: string - Filter by country
+   * @returns Promise with average session data
+   */
+  public static sessionsAverage<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.sessionsAverage,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get session duration histogram data
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - bucket_size?: number - Duration bucket size in seconds
+   * @returns Promise with histogram data
+   */
+  public static sessionsHistogram<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.sessionsHistogram,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get pageviews over time with optional grouping
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - group_by?: 'hour'|'day'|'week'|'month' - Grouping period
+   *   - path?: string - Filter by specific path
+   * @returns Promise with pageviews over time data
+   */
+  public static pageviewsOverTime<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.pageviewsOverTime,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get top pages by views
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - limit?: number - Number of top pages to return
+   * @returns Promise with top pages data
+   */
+  public static topPages<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.topPages,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get summary of events
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - event_category?: string - Filter by event category
+   * @returns Promise with events summary data
+   */
+  public static eventsSummary<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.eventsSummary,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get most popular events
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - limit?: number - Number of events to return
+   * @returns Promise with popular events data
+   */
+  public static popularEvents<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.popularEvents,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get geographic distribution of visitors
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - limit?: number - Number of countries to return
+   * @returns Promise with geo distribution data
+   */
+  public static geoDistribution<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.geoDistribution,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get device type breakdown
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   * @returns Promise with device breakdown data
+   */
+  public static deviceBreakdown<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.deviceBreakdown,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get top referrers
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - limit?: number - Number of referrers to return
+   * @returns Promise with referrers data
+   */
+  public static referrers<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.referrers,
+      {},
+      undefined,
+      params
+    );
+  }
+
+  /**
+   * Get UTM campaign performance
+   * 
+   * @param params Filtering options:
+   *   - title_id?: string - Filter by title ID
+   *   - start_date?: string - Start date (YYYY-MM-DD)
+   *   - end_date?: string - End date (YYYY-MM-DD)
+   *   - group_by?: 'source'|'medium'|'campaign' - Grouping field
+   * @returns Promise with UTM performance data
+   */
+  public static utmPerformance<T>(params?: Record<string, any>): AxiosPromise<Response<T>> {
+    return Requests.processRoute(
+      WebsiteAnalyticsRoute.routes.utmPerformance,
+      {},
+      undefined,
+      params
+    );
+  }
+}
+
+export default WebsiteAnalytics;

package/src/api/index.ts

@@ -31,6 +31,7 @@ import Scheduler from "./Scheduler";
 import Funnel from "./Funnel";
 import SocialStats from "./SocialStats";
 import Hashtags from "./Hashtags";
+import WebsiteAnalytics from "./WebsiteAnalytics";
 
 export {Ads};
 export {Auth};
@@ -64,4 +65,5 @@ export {Media};
 export {Scheduler};
 export {Funnel};
 export {SocialStats};
-export {Hashtags};
+export {Hashtags};
+export {WebsiteAnalytics};

package/src/index.ts

@@ -35,6 +35,7 @@ import {Scheduler} from "./api";
 import {Funnel} from "./api";
 import {SocialStats} from "./api";
 import {Hashtags} from "./api";
+import {WebsiteAnalytics} from "./api";
 
 import Requests from "./util/Requests";
 import Parser from "./util/Parser";
@@ -98,7 +99,8 @@ class Glitch {
         Media : Media,
         Scheduler : Scheduler,
         Funnel: Funnel,
-        SocialStats : SocialStats
+        SocialStats : SocialStats,
+        WebsiteAnalytics: WebsiteAnalytics
     }
 
     public static util = {

package/src/routes/AdsRoute.ts

@@ -136,6 +136,36 @@ class AdsRoute {
             url: "/ads/campaigns/{campaign_id}/groups/{group_id}/triggers/{trigger_id}",
             method: HTTP_METHODS.DELETE,
         },
+
+        // REDDIT TARGETING routes
+        getRedditCarriers: {
+            url: "/ads/reddit/targeting/carriers",
+            method: HTTP_METHODS.GET,
+        },
+        getRedditCommunities: {
+            url: "/ads/reddit/targeting/communities",
+            method: HTTP_METHODS.GET,
+        },
+        searchRedditCommunities: {
+            url: "/ads/reddit/targeting/communities/search",
+            method: HTTP_METHODS.GET,
+        },
+        getRedditDevices: {
+            url: "/ads/reddit/targeting/devices",
+            method: HTTP_METHODS.GET,
+        },
+        getRedditGeolocations: {
+            url: "/ads/reddit/targeting/geolocations",
+            method: HTTP_METHODS.GET,
+        },
+        getRedditInterests: {
+            url: "/ads/reddit/targeting/interests",
+            method: HTTP_METHODS.GET,
+        },
+        getRedditThirdPartyAudiences: {
+            url: "/ads/reddit/targeting/third_party_audiences",
+            method: HTTP_METHODS.GET,
+        },
     };
 }
 

package/src/routes/SchedulerRoute.ts

@@ -13,6 +13,7 @@ class SchedulerRoute {
 
         // Title Update Routes
         listUpdates: { url: '/schedulers/{scheduler_id}/updates', method: HTTP_METHODS.GET },
+        searchUpdates: { url: '/schedulers/{scheduler_id}/updates/search', method: HTTP_METHODS.GET },
         createUpdate: { url: '/schedulers/{scheduler_id}/updates', method: HTTP_METHODS.POST },
         getUpdate: { url: '/schedulers/{scheduler_id}/updates/{update_id}', method: HTTP_METHODS.GET },
         updateUpdate: { url: '/schedulers/{scheduler_id}/updates/{update_id}', method: HTTP_METHODS.PUT },
@@ -32,6 +33,7 @@ class SchedulerRoute {
         clearTwitchAuth: { url: '/schedulers/{scheduler_id}/clearTwitchAuth', method: HTTP_METHODS.DELETE },
         clearKickAuth: { url: '/schedulers/{scheduler_id}/clearKickAuth', method: HTTP_METHODS.DELETE },
         clearRedditAuth: { url: '/schedulers/{scheduler_id}/clearRedditAuth', method: HTTP_METHODS.DELETE },
+        clearRedditAdsAuth: { url: '/schedulers/{scheduler_id}/clearRedditAdsAuth', method: HTTP_METHODS.DELETE },
         clearYouTubeAuth: { url: '/schedulers/{scheduler_id}/clearYouTubeAuth', method: HTTP_METHODS.DELETE },
         clearPatreonAuth: { url: '/schedulers/{scheduler_id}/clearPatreonAuth', method: HTTP_METHODS.DELETE },
         clearPinterestAuth: { url: '/schedulers/{scheduler_id}/clearPinterestAuth', method: HTTP_METHODS.DELETE },

package/src/routes/WebsiteAnalyticsRoute.ts

@@ -0,0 +1,69 @@
+import Route from "./interface";
+import HTTP_METHODS from "../constants/HttpMethods";
+
+class WebsiteAnalyticsRoute {
+  public static routes: { [key: string]: Route } = {
+    listSessions: {
+      url: '/analytics/sessions',
+      method: HTTP_METHODS.GET
+    },
+    listPageviews: {
+      url: '/analytics/pageviews',
+      method: HTTP_METHODS.GET
+    },
+    listEvents: {
+      url: '/analytics/events',
+      method: HTTP_METHODS.GET
+    },
+    overview: {
+      url: '/analytics/overview',
+      method: HTTP_METHODS.GET
+    },
+    collect: {
+      url: '/analytics/collect',
+      method: HTTP_METHODS.POST
+    },
+    sessionsAverage: {
+      url: '/analytics/sessions/average',
+      method: HTTP_METHODS.GET
+    },
+    sessionsHistogram: {
+      url: '/analytics/sessions/histogram',
+      method: HTTP_METHODS.GET
+    },
+    pageviewsOverTime: {
+      url: '/analytics/pageviews/over-time',
+      method: HTTP_METHODS.GET
+    },
+    topPages: {
+      url: '/analytics/pageviews/top-pages',
+      method: HTTP_METHODS.GET
+    },
+    eventsSummary: {
+      url: '/analytics/events/summary',
+      method: HTTP_METHODS.GET
+    },
+    popularEvents: {
+      url: '/analytics/events/popular',
+      method: HTTP_METHODS.GET
+    },
+    geoDistribution: {
+      url: '/analytics/geo-distribution',
+      method: HTTP_METHODS.GET
+    },
+    deviceBreakdown: {
+      url: '/analytics/device-breakdown',
+      method: HTTP_METHODS.GET
+    },
+    referrers: {
+      url: '/analytics/referrers',
+      method: HTTP_METHODS.GET
+    },
+    utmPerformance: {
+      url: '/analytics/utm-performance',
+      method: HTTP_METHODS.GET
+    }
+  };
+}
+
+export default WebsiteAnalyticsRoute;

package/src/util/Session.ts

@@ -1,8 +1,70 @@
 import { Config } from "../config";
 import Storage from "./Storage";
 
-class Session {
+// Type declarations for crypto functionality
+interface HmacInterface {
+  update(data: string): HmacInterface;
+  digest(encoding: 'hex'): string;
+}
+
+interface CryptoInterface {
+  createHmac(algorithm: string, secret: string): HmacInterface;
+}
+
+// Browser implementation using crypto-js
+class BrowserCrypto implements CryptoInterface {
+  createHmac(algorithm: string, secret: string): HmacInterface {
+    const CryptoJS = require('crypto-js');
+    
+    let data = '';
+    
+    const hmac: HmacInterface = {
+      update: (updateData: string): HmacInterface => {
+        data = updateData;
+        return hmac;
+      },
+      digest: (encoding: 'hex'): string => {
+        if (encoding !== 'hex') {
+          throw new Error('Only hex encoding is supported in browser implementation');
+        }
+        return CryptoJS.HmacSHA256(data, secret).toString(CryptoJS.enc.Hex);
+      }
+    };
+    
+    return hmac;
+  }
+}
+
+// Node.js implementation using native crypto
+class NodeCrypto implements CryptoInterface {
+  private crypto: typeof import('crypto');
+
+  constructor() {
+    this.crypto = require('crypto');
+  }
+
+  createHmac(algorithm: string, secret: string): HmacInterface {
+    return this.crypto.createHmac(algorithm, secret);
+  }
+}
+
+// Determine which crypto implementation to use
+const getCrypto = (): CryptoInterface => {
+  try {
+    // Check if we're in Node.js environment
+    if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+      return new NodeCrypto();
+    }
+    // Fall back to browser implementation
+    return new BrowserCrypto();
+  } catch (e) {
+    return new BrowserCrypto();
+  }
+};
+
+const crypto = getCrypto();
 
+class Session {
   private static _id_key = 'user_id';
   private static _first_name_key = 'user_first_name';
   private static _last_name_key = 'user_last_name';
@@ -37,7 +99,7 @@ class Session {
   public static hasJoinedCommunity() {
     const community = Storage.get('community');
 
-    if(!community) {
+    if (!community) {
       return false;
     }
 
@@ -53,7 +115,7 @@ class Session {
     Storage.set(Session._username_key, null);
   }
 
-  public static processAuthentication(data: { token: { access_token: string }, id: string, first_name: string, last_name: string, email: string, username: string  }): void {
+  public static processAuthentication(data: { token: { access_token: string }, id: string, first_name: string, last_name: string, email: string, username: string }): void {
     Storage.setAuthToken(data.token.access_token);
     Storage.set(Session._id_key, data.id);
     Storage.set(Session._first_name_key, data.first_name);
@@ -63,6 +125,32 @@ class Session {
 
     Config.setAuthToken(data.token.access_token);
   }
+
+  /**
+   * Generate a tracking token for analytics collection
+   * @param titleId The title ID to generate token for
+   * @param secret The secret key (should match server config)
+   * @returns HMAC-SHA256 token
+   * @throws Error if crypto operations fail
+   */
+  public static generateTrackingToken(titleId: string, secret: string): string {
+    try {
+      if (!titleId) {
+        throw new Error('titleId is required');
+      }
+      if (!secret) {
+        throw new Error('secret is required');
+      }
+
+      return crypto
+        .createHmac('sha256', secret)
+        .update(titleId)
+        .digest('hex');
+    } catch (error) {
+      console.error('Failed to generate tracking token:', error);
+      throw new Error('Failed to generate tracking token');
+    }
+  }
 }
 
-export default Session;
+export default Session;