@hasna/connectors 0.0.1

package/connectors/connect-youtube/src/api/subscriptions.ts

@@ -0,0 +1,164 @@
+import type { YouTubeClient } from './client';
+import type {
+  Subscription,
+  SubscriptionListParams,
+  ListResponse,
+} from '../types';
+
+export interface SubscriptionInsertParams {
+  part: string[];
+}
+
+export class SubscriptionsApi {
+  constructor(private readonly client: YouTubeClient) {}
+
+  /**
+   * List subscriptions
+   * Quota cost: 1 unit per request
+   */
+  async list(params: SubscriptionListParams): Promise<ListResponse<Subscription>> {
+    return this.client.get<ListResponse<Subscription>>('/subscriptions', {
+      part: params.part,
+      channelId: params.channelId,
+      id: params.id,
+      mine: params.mine,
+      myRecentSubscribers: params.myRecentSubscribers,
+      mySubscribers: params.mySubscribers,
+      forChannelId: params.forChannelId,
+      maxResults: params.maxResults,
+      onBehalfOfContentOwner: params.onBehalfOfContentOwner,
+      onBehalfOfContentOwnerChannel: params.onBehalfOfContentOwnerChannel,
+      order: params.order,
+      pageToken: params.pageToken,
+    });
+  }
+
+  /**
+   * Get the authenticated user's subscriptions
+   */
+  async getMine(
+    maxResults = 25,
+    order: 'alphabetical' | 'relevance' | 'unread' = 'relevance',
+    parts: string[] = ['snippet', 'contentDetails']
+  ): Promise<ListResponse<Subscription>> {
+    return this.list({
+      part: parts,
+      mine: true,
+      maxResults,
+      order,
+    });
+  }
+
+  /**
+   * Get subscriptions for a channel
+   */
+  async getForChannel(
+    channelId: string,
+    maxResults = 25,
+    order: 'alphabetical' | 'relevance' | 'unread' = 'relevance',
+    parts: string[] = ['snippet', 'contentDetails']
+  ): Promise<ListResponse<Subscription>> {
+    return this.list({
+      part: parts,
+      channelId,
+      maxResults,
+      order,
+    });
+  }
+
+  /**
+   * Check if subscribed to specific channels
+   */
+  async checkSubscription(
+    forChannelIds: string | string[],
+    parts: string[] = ['snippet']
+  ): Promise<ListResponse<Subscription>> {
+    const channelIds = Array.isArray(forChannelIds) ? forChannelIds.join(',') : forChannelIds;
+    return this.list({
+      part: parts,
+      mine: true,
+      forChannelId: channelIds,
+    });
+  }
+
+  /**
+   * Get the authenticated user's subscribers
+   */
+  async getMySubscribers(
+    maxResults = 25,
+    parts: string[] = ['snippet', 'subscriberSnippet']
+  ): Promise<ListResponse<Subscription>> {
+    return this.list({
+      part: parts,
+      mySubscribers: true,
+      maxResults,
+    });
+  }
+
+  /**
+   * Get the authenticated user's recent subscribers
+   */
+  async getMyRecentSubscribers(
+    maxResults = 25,
+    parts: string[] = ['snippet', 'subscriberSnippet']
+  ): Promise<ListResponse<Subscription>> {
+    return this.list({
+      part: parts,
+      myRecentSubscribers: true,
+      maxResults,
+    });
+  }
+
+  /**
+   * Insert (create) a subscription
+   * Quota cost: 50 units
+   */
+  async insert(
+    subscription: Omit<Subscription, 'kind' | 'etag' | 'id'>,
+    params: SubscriptionInsertParams
+  ): Promise<Subscription> {
+    return this.client.post<Subscription>(
+      '/subscriptions',
+      subscription as Record<string, unknown>,
+      { part: params.part }
+    );
+  }
+
+  /**
+   * Subscribe to a channel
+   */
+  async subscribe(channelId: string): Promise<Subscription> {
+    return this.insert(
+      {
+        snippet: {
+          resourceId: {
+            kind: 'youtube#channel',
+            channelId,
+          },
+        },
+      } as Omit<Subscription, 'kind' | 'etag' | 'id'>,
+      { part: ['snippet'] }
+    );
+  }
+
+  /**
+   * Delete a subscription
+   * Quota cost: 50 units
+   */
+  async delete(subscriptionId: string): Promise<void> {
+    await this.client.delete('/subscriptions', { id: subscriptionId });
+  }
+
+  /**
+   * Unsubscribe from a channel
+   * First finds the subscription, then deletes it
+   */
+  async unsubscribe(channelId: string): Promise<boolean> {
+    const response = await this.checkSubscription(channelId);
+    if (response.items.length > 0) {
+      await this.delete(response.items[0].id);
+      return true;
+    }
+    return false;
+  }
+}

package/connectors/connect-youtube/src/api/thumbnails.ts

@@ -0,0 +1,73 @@
+import type { YouTubeClient } from './client';
+import type { ThumbnailDetails } from '../types';
+
+export interface ThumbnailSetResponse {
+  kind: 'youtube#thumbnailSetResponse';
+  etag: string;
+  items: Array<{
+    default?: ThumbnailDetails['default'];
+    medium?: ThumbnailDetails['medium'];
+    high?: ThumbnailDetails['high'];
+    standard?: ThumbnailDetails['standard'];
+    maxres?: ThumbnailDetails['maxres'];
+  }>;
+}
+
+export class ThumbnailsApi {
+  constructor(private readonly client: YouTubeClient) {}
+
+  /**
+   * Set a custom thumbnail for a video
+   * Quota cost: 50 units
+   *
+   * Note: This requires the video owner to have verified their account
+   * and the image should be:
+   * - 1280x720 pixels (min 640x360)
+   * - Under 2MB
+   * - JPG, GIF, or PNG format
+   */
+  async set(
+    videoId: string,
+    imageData: Buffer | Uint8Array,
+    contentType: 'image/jpeg' | 'image/png' | 'image/gif' = 'image/jpeg',
+    onBehalfOfContentOwner?: string
+  ): Promise<ThumbnailSetResponse> {
+    // Initialize resumable upload for thumbnail
+    const uploadUrl = await this.client.initResumableUpload(
+      '/thumbnails/set',
+      {},
+      contentType,
+      imageData.length
+    );
+
+    // Upload the image
+    const data = imageData instanceof Uint8Array ? imageData : new Uint8Array(imageData);
+    const result = await this.client.uploadChunk(uploadUrl, data, 0, data.length);
+
+    if (result.complete) {
+      return result.response as ThumbnailSetResponse;
+    }
+
+    throw new Error('Thumbnail upload did not complete');
+  }
+
+  /**
+   * Set thumbnail from a file path (Node.js/Bun environment)
+   */
+  async setFromFile(
+    videoId: string,
+    filePath: string,
+    onBehalfOfContentOwner?: string
+  ): Promise<ThumbnailSetResponse> {
+    const { readFileSync } = await import('fs');
+    const imageData = readFileSync(filePath);
+
+    // Determine content type from file extension
+    let contentType: 'image/jpeg' | 'image/png' | 'image/gif' = 'image/jpeg';
+    const ext = filePath.toLowerCase().split('.').pop();
+    if (ext === 'png') contentType = 'image/png';
+    else if (ext === 'gif') contentType = 'image/gif';
+
+    return this.set(videoId, imageData, contentType, onBehalfOfContentOwner);
+  }
+}

package/connectors/connect-youtube/src/api/videos.ts

@@ -0,0 +1,217 @@
+import type { YouTubeClient } from './client';
+import type {
+  Video,
+  VideoListParams,
+  VideoInsertParams,
+  VideoUpdateParams,
+  VideoRating,
+  VideoRatingListResponse,
+  VideoAbuseReportReason,
+  ListResponse,
+  UploadProgress,
+} from '../types';
+
+const CHUNK_SIZE = 256 * 1024; // 256KB chunks for resumable upload
+
+export class VideosApi {
+  constructor(private readonly client: YouTubeClient) {}
+
+  /**
+   * List videos
+   * Quota cost: 1 unit per request
+   */
+  async list(params: VideoListParams): Promise<ListResponse<Video>> {
+    return this.client.get<ListResponse<Video>>('/videos', {
+      part: params.part,
+      chart: params.chart,
+      id: params.id,
+      myRating: params.myRating,
+      hl: params.hl,
+      maxHeight: params.maxHeight,
+      maxResults: params.maxResults,
+      maxWidth: params.maxWidth,
+      onBehalfOfContentOwner: params.onBehalfOfContentOwner,
+      pageToken: params.pageToken,
+      regionCode: params.regionCode,
+      videoCategoryId: params.videoCategoryId,
+    });
+  }
+
+  /**
+   * Get a single video by ID
+   */
+  async get(videoId: string, parts: string[] = ['snippet', 'contentDetails', 'statistics', 'status']): Promise<Video | null> {
+    const response = await this.list({ part: parts, id: videoId });
+    return response.items[0] || null;
+  }
+
+  /**
+   * Get multiple videos by IDs
+   */
+  async getMany(videoIds: string[], parts: string[] = ['snippet', 'contentDetails', 'statistics']): Promise<Video[]> {
+    const response = await this.list({ part: parts, id: videoIds });
+    return response.items;
+  }
+
+  /**
+   * Get most popular videos
+   */
+  async getMostPopular(
+    regionCode?: string,
+    categoryId?: string,
+    maxResults = 25,
+    parts: string[] = ['snippet', 'contentDetails', 'statistics']
+  ): Promise<ListResponse<Video>> {
+    return this.list({
+      part: parts,
+      chart: 'mostPopular',
+      regionCode,
+      videoCategoryId: categoryId,
+      maxResults,
+    });
+  }
+
+  /**
+   * Insert (upload) a video
+   * Quota cost: 1600 units
+   *
+   * Note: For large files, use uploadResumable instead
+   */
+  async insert(
+    videoData: Buffer | Uint8Array,
+    metadata: Partial<Video>,
+    params: VideoInsertParams,
+    onProgress?: (progress: UploadProgress) => void
+  ): Promise<Video> {
+    // Use resumable upload for all uploads
+    return this.uploadResumable(videoData, metadata, params, onProgress);
+  }
+
+  /**
+   * Upload a video using resumable upload
+   * Quota cost: 1600 units
+   */
+  async uploadResumable(
+    videoData: Buffer | Uint8Array,
+    metadata: Partial<Video>,
+    params: VideoInsertParams,
+    onProgress?: (progress: UploadProgress) => void
+  ): Promise<Video> {
+    const totalSize = videoData.length;
+
+    // Initialize resumable upload
+    const uploadUrl = await this.client.initResumableUpload(
+      '/videos',
+      {
+        ...metadata,
+        part: params.part.join(','),
+      },
+      'video/*',
+      totalSize
+    );
+
+    // Upload in chunks
+    let bytesUploaded = 0;
+    const data = videoData instanceof Uint8Array ? videoData : new Uint8Array(videoData);
+
+    while (bytesUploaded < totalSize) {
+      const chunkEnd = Math.min(bytesUploaded + CHUNK_SIZE, totalSize);
+      const chunk = data.slice(bytesUploaded, chunkEnd);
+
+      const result = await this.client.uploadChunk(uploadUrl, chunk, bytesUploaded, totalSize);
+      bytesUploaded = result.bytesUploaded;
+
+      if (onProgress) {
+        onProgress({
+          bytesUploaded,
+          totalBytes: totalSize,
+          percentage: Math.round((bytesUploaded / totalSize) * 100),
+        });
+      }
+
+      if (result.complete) {
+        return result.response as Video;
+      }
+    }
+
+    throw new Error('Upload did not complete');
+  }
+
+  /**
+   * Update a video
+   * Quota cost: 50 units
+   */
+  async update(video: Partial<Video> & { id: string }, params: VideoUpdateParams): Promise<Video> {
+    return this.client.put<Video>('/videos', video as Record<string, unknown>, {
+      part: params.part,
+      onBehalfOfContentOwner: params.onBehalfOfContentOwner,
+    });
+  }
+
+  /**
+   * Delete a video
+   * Quota cost: 50 units
+   */
+  async delete(videoId: string, onBehalfOfContentOwner?: string): Promise<void> {
+    await this.client.delete('/videos', {
+      id: videoId,
+      onBehalfOfContentOwner,
+    });
+  }
+
+  /**
+   * Rate a video (like, dislike, or remove rating)
+   * Quota cost: 50 units
+   */
+  async rate(videoId: string, rating: 'like' | 'dislike' | 'none'): Promise<void> {
+    await this.client.post('/videos/rate', undefined, {
+      id: videoId,
+      rating,
+    });
+  }
+
+  /**
+   * Get rating for videos
+   * Quota cost: 1 unit
+   */
+  async getRating(videoIds: string | string[], onBehalfOfContentOwner?: string): Promise<VideoRatingListResponse> {
+    return this.client.get<VideoRatingListResponse>('/videos/getRating', {
+      id: videoIds,
+      onBehalfOfContentOwner,
+    });
+  }
+
+  /**
+   * Report a video for abuse
+   * Quota cost: 50 units
+   */
+  async reportAbuse(
+    videoId: string,
+    reasonId: string,
+    secondaryReasonId?: string,
+    comments?: string,
+    language?: string,
+    onBehalfOfContentOwner?: string
+  ): Promise<void> {
+    await this.client.post('/videos/reportAbuse', {
+      videoId,
+      reasonId,
+      secondaryReasonId,
+      comments,
+      language,
+    }, {
+      onBehalfOfContentOwner,
+    });
+  }
+
+  /**
+   * List video abuse report reasons
+   * Quota cost: 1 unit
+   */
+  async listAbuseReportReasons(hl?: string): Promise<ListResponse<VideoAbuseReportReason>> {
+    return this.client.get<ListResponse<VideoAbuseReportReason>>('/videoAbuseReportReasons', {
+      part: ['snippet'],
+      hl,
+    });
+  }
+}

package/connectors/connect-youtube/src/api/watermarks.ts

@@ -0,0 +1,110 @@
+import type { YouTubeClient } from './client';
+import type { InvideoBranding, WatermarkTiming, WatermarkPosition } from '../types';
+
+export interface WatermarkSetParams {
+  channelId: string;
+  onBehalfOfContentOwner?: string;
+}
+
+export class WatermarksApi {
+  constructor(private readonly client: YouTubeClient) {}
+
+  /**
+   * Set a watermark (branding) image for a channel
+   * Quota cost: 50 units
+   *
+   * The watermark image should be:
+   * - PNG or GIF format (GIF for animated)
+   * - Transparent background recommended
+   * - 150x150 pixels recommended
+   */
+  async set(
+    channelId: string,
+    imageData: Buffer | Uint8Array,
+    timing: WatermarkTiming,
+    position?: WatermarkPosition,
+    onBehalfOfContentOwner?: string
+  ): Promise<void> {
+    const branding: InvideoBranding = {
+      targetChannelId: channelId,
+      timing,
+      position: position || {
+        type: 'corner',
+        cornerPosition: 'bottomRight',
+      },
+    };
+
+    // For image upload, we need to use multipart
+    // This is a simplified version that uses base64 encoding
+    const imageBase64 = Buffer.from(imageData).toString('base64');
+    branding.imageBytes = imageBase64;
+
+    await this.client.post('/watermarks/set', branding as unknown as Record<string, unknown>, {
+      channelId,
+      onBehalfOfContentOwner,
+    });
+  }
+
+  /**
+   * Set watermark from file
+   */
+  async setFromFile(
+    channelId: string,
+    filePath: string,
+    timing: WatermarkTiming,
+    position?: WatermarkPosition,
+    onBehalfOfContentOwner?: string
+  ): Promise<void> {
+    const { readFileSync } = await import('fs');
+    const imageData = readFileSync(filePath);
+    return this.set(channelId, imageData, timing, position, onBehalfOfContentOwner);
+  }
+
+  /**
+   * Set watermark to show from start of video
+   */
+  async setFromStart(
+    channelId: string,
+    imageData: Buffer | Uint8Array,
+    offsetMs = 0,
+    durationMs?: string,
+    position?: WatermarkPosition
+  ): Promise<void> {
+    return this.set(channelId, imageData, {
+      type: 'offsetFromStart',
+      offsetMs: String(offsetMs),
+      durationMs,
+    }, position);
+  }
+
+  /**
+   * Set watermark to show until end of video
+   */
+  async setFromEnd(
+    channelId: string,
+    imageData: Buffer | Uint8Array,
+    offsetMs = 0,
+    durationMs?: string,
+    position?: WatermarkPosition
+  ): Promise<void> {
+    return this.set(channelId, imageData, {
+      type: 'offsetFromEnd',
+      offsetMs: String(offsetMs),
+      durationMs,
+    }, position);
+  }
+
+  /**
+   * Remove/unset watermark from a channel
+   * Quota cost: 50 units
+   */
+  async unset(
+    channelId: string,
+    onBehalfOfContentOwner?: string
+  ): Promise<void> {
+    await this.client.post('/watermarks/unset', undefined, {
+      channelId,
+      onBehalfOfContentOwner,
+    });
+  }
+}