@hasna/connectors 0.0.1

package/connectors/connect-snap/src/api/media.ts

@@ -0,0 +1,246 @@
+import type { SnapClient } from './client';
+import type {
+  Media,
+  MediaCreateParams,
+  MediaResponse,
+  MediaType,
+} from '../types';
+import { readFileSync, statSync } from 'fs';
+import { basename } from 'path';
+
+// 32 MB chunk size for large file uploads
+const CHUNK_SIZE = 32 * 1024 * 1024;
+
+/**
+ * Snapchat Media API
+ * Upload and manage media files (images, videos)
+ */
+export class MediaApi {
+  constructor(private readonly client: SnapClient) {}
+
+  /**
+   * List all media for an ad account
+   */
+  async list(adAccountId: string): Promise<Media[]> {
+    const response = await this.client.get<MediaResponse>(
+      `/adaccounts/${adAccountId}/media`
+    );
+    return response.media?.map(m => m.media) || [];
+  }
+
+  /**
+   * Get a specific media by ID
+   */
+  async get(mediaId: string): Promise<Media> {
+    const response = await this.client.get<MediaResponse>(`/media/${mediaId}`);
+    const media = response.media?.[0]?.media;
+    if (!media) {
+      throw new Error(`Media ${mediaId} not found`);
+    }
+    return media;
+  }
+
+  /**
+   * Create a media placeholder (before upload)
+   */
+  async create(params: MediaCreateParams): Promise<Media> {
+    const response = await this.client.post<MediaResponse>(
+      `/adaccounts/${params.ad_account_id}/media`,
+      {
+        media: [params],
+      }
+    );
+    const media = response.media?.[0]?.media;
+    if (!media) {
+      throw new Error('Failed to create media');
+    }
+    return media;
+  }
+
+  /**
+   * Upload media from a file path
+   * Automatically handles chunked upload for large files
+   */
+  async uploadFile(
+    adAccountId: string,
+    filePath: string,
+    type: MediaType,
+    name?: string
+  ): Promise<Media> {
+    const fileStats = statSync(filePath);
+    const fileName = name || basename(filePath);
+    const fileSize = fileStats.size;
+
+    // For files larger than chunk size, use chunked upload
+    if (fileSize > CHUNK_SIZE) {
+      return this.uploadLargeFile(adAccountId, filePath, type, fileName);
+    }
+
+    // For smaller files, use direct upload
+    return this.uploadSmallFile(adAccountId, filePath, type, fileName);
+  }
+
+  /**
+   * Upload a small file directly (< 32 MB)
+   */
+  private async uploadSmallFile(
+    adAccountId: string,
+    filePath: string,
+    type: MediaType,
+    fileName: string
+  ): Promise<Media> {
+    // Create media placeholder
+    const media = await this.create({
+      ad_account_id: adAccountId,
+      type,
+      name: fileName,
+    });
+
+    // Upload the file
+    const fileContent = readFileSync(filePath);
+    const blob = new Blob([fileContent]);
+
+    const formData = new FormData();
+    formData.append('file', blob, fileName);
+
+    await this.client.upload<{ request_status: string }>(
+      `/media/${media.id}/upload`,
+      formData
+    );
+
+    // Return updated media
+    return this.get(media.id);
+  }
+
+  /**
+   * Upload a large file using chunked upload (> 32 MB)
+   */
+  private async uploadLargeFile(
+    adAccountId: string,
+    filePath: string,
+    type: MediaType,
+    fileName: string
+  ): Promise<Media> {
+    const fileStats = statSync(filePath);
+    const fileSize = fileStats.size;
+    const numberOfParts = Math.ceil(fileSize / CHUNK_SIZE);
+
+    // Create media placeholder
+    const media = await this.create({
+      ad_account_id: adAccountId,
+      type,
+      name: fileName,
+    });
+
+    // Initialize chunked upload
+    const initResponse = await this.client.post<{
+      request_status: string;
+      upload_id: string;
+    }>(`/media/${media.id}/multipart-upload`, {
+      file_name: fileName,
+      file_size: fileSize,
+      number_of_parts: numberOfParts,
+    });
+
+    const uploadId = initResponse.upload_id;
+    const parts: { part_number: number; etag: string }[] = [];
+
+    // Read file content
+    const fileContent = readFileSync(filePath);
+
+    // Upload each part
+    for (let partNumber = 1; partNumber <= numberOfParts; partNumber++) {
+      const start = (partNumber - 1) * CHUNK_SIZE;
+      const end = Math.min(start + CHUNK_SIZE, fileSize);
+      const chunk = fileContent.slice(start, end);
+
+      const blob = new Blob([chunk]);
+      const formData = new FormData();
+      formData.append('file', blob, `part_${partNumber}`);
+
+      const partResponse = await this.client.upload<{
+        request_status: string;
+        etag: string;
+      }>(`/media/${media.id}/multipart-upload/${uploadId}/parts/${partNumber}`, formData);
+
+      parts.push({
+        part_number: partNumber,
+        etag: partResponse.etag,
+      });
+    }
+
+    // Complete the upload
+    await this.client.post<{ request_status: string }>(
+      `/media/${media.id}/multipart-upload/${uploadId}/complete`,
+      { parts }
+    );
+
+    // Return updated media
+    return this.get(media.id);
+  }
+
+  /**
+   * Upload video from a file path
+   */
+  async uploadVideo(adAccountId: string, filePath: string, name?: string): Promise<Media> {
+    return this.uploadFile(adAccountId, filePath, 'VIDEO', name);
+  }
+
+  /**
+   * Upload image from a file path
+   */
+  async uploadImage(adAccountId: string, filePath: string, name?: string): Promise<Media> {
+    return this.uploadFile(adAccountId, filePath, 'IMAGE', name);
+  }
+
+  /**
+   * Get thumbnail URL for a media
+   */
+  async getThumbnail(mediaId: string): Promise<string> {
+    const media = await this.get(mediaId);
+    return media.download_link || '';
+  }
+
+  /**
+   * Delete media
+   */
+  async delete(mediaId: string): Promise<void> {
+    await this.client.delete(`/media/${mediaId}`);
+  }
+
+  /**
+   * Check media processing status
+   */
+  async checkStatus(mediaId: string): Promise<{ status: string; ready: boolean }> {
+    const media = await this.get(mediaId);
+    return {
+      status: media.media_status,
+      ready: media.media_status === 'READY',
+    };
+  }
+
+  /**
+   * Wait for media to be ready (poll until processed)
+   */
+  async waitForReady(mediaId: string, timeoutMs: number = 300000): Promise<Media> {
+    const startTime = Date.now();
+    const pollInterval = 5000; // 5 seconds
+
+    while (Date.now() - startTime < timeoutMs) {
+      const media = await this.get(mediaId);
+
+      if (media.media_status === 'READY') {
+        return media;
+      }
+
+      if (media.media_status === 'FAILED') {
+        throw new Error(`Media processing failed for ${mediaId}`);
+      }
+
+      // Wait before polling again
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+
+    throw new Error(`Timeout waiting for media ${mediaId} to be ready`);
+  }
+}

package/connectors/connect-snap/src/api/organizations.ts

@@ -0,0 +1,30 @@
+import type { SnapClient } from './client';
+import type { Organization, OrganizationResponse } from '../types';
+
+/**
+ * Snapchat Organizations API
+ * Manage organizations (business entities)
+ */
+export class OrganizationsApi {
+  constructor(private readonly client: SnapClient) {}
+
+  /**
+   * Get all organizations the authenticated user has access to
+   */
+  async list(): Promise<Organization[]> {
+    const response = await this.client.get<OrganizationResponse>('/me/organizations');
+    return response.organizations?.map(o => o.organization) || [];
+  }
+
+  /**
+   * Get a specific organization by ID
+   */
+  async get(organizationId: string): Promise<Organization> {
+    const response = await this.client.get<OrganizationResponse>(`/organizations/${organizationId}`);
+    const org = response.organizations?.[0]?.organization;
+    if (!org) {
+      throw new Error(`Organization ${organizationId} not found`);
+    }
+    return org;
+  }
+}

package/connectors/connect-snap/src/api/pixels.ts

@@ -0,0 +1,215 @@
+import type { SnapClient } from './client';
+import type {
+  Pixel,
+  PixelCreateParams,
+  PixelUpdateParams,
+  PixelResponse,
+} from '../types';
+
+/**
+ * Snapchat Pixels API
+ * Manage Snap Pixel for conversion tracking
+ */
+export class PixelsApi {
+  constructor(private readonly client: SnapClient) {}
+
+  /**
+   * List all pixels for an ad account
+   */
+  async list(adAccountId: string): Promise<Pixel[]> {
+    const response = await this.client.get<PixelResponse>(
+      `/adaccounts/${adAccountId}/pixels`
+    );
+    return response.pixels?.map(p => p.pixel) || [];
+  }
+
+  /**
+   * Get a specific pixel by ID
+   */
+  async get(pixelId: string): Promise<Pixel> {
+    const response = await this.client.get<PixelResponse>(`/pixels/${pixelId}`);
+    const pixel = response.pixels?.[0]?.pixel;
+    if (!pixel) {
+      throw new Error(`Pixel ${pixelId} not found`);
+    }
+    return pixel;
+  }
+
+  /**
+   * Create a new pixel
+   */
+  async create(params: PixelCreateParams): Promise<Pixel> {
+    const response = await this.client.post<PixelResponse>(
+      `/adaccounts/${params.ad_account_id}/pixels`,
+      {
+        pixels: [params],
+      }
+    );
+    const pixel = response.pixels?.[0]?.pixel;
+    if (!pixel) {
+      throw new Error('Failed to create pixel');
+    }
+    return pixel;
+  }
+
+  /**
+   * Update a pixel
+   */
+  async update(pixelId: string, params: PixelUpdateParams): Promise<Pixel> {
+    const response = await this.client.put<PixelResponse>(
+      `/pixels/${pixelId}`,
+      {
+        pixels: [{ id: pixelId, ...params }],
+      }
+    );
+    const pixel = response.pixels?.[0]?.pixel;
+    if (!pixel) {
+      throw new Error('Failed to update pixel');
+    }
+    return pixel;
+  }
+
+  /**
+   * Delete a pixel
+   */
+  async delete(pixelId: string): Promise<void> {
+    await this.client.delete(`/pixels/${pixelId}`);
+  }
+
+  /**
+   * Pause a pixel
+   */
+  async pause(pixelId: string): Promise<Pixel> {
+    return this.update(pixelId, { status: 'PAUSED' });
+  }
+
+  /**
+   * Activate a pixel
+   */
+  async activate(pixelId: string): Promise<Pixel> {
+    return this.update(pixelId, { status: 'ACTIVE' });
+  }
+
+  /**
+   * Get pixel JavaScript code
+   */
+  async getCode(pixelId: string): Promise<string> {
+    const pixel = await this.get(pixelId);
+    return pixel.pixel_javascript || '';
+  }
+
+  /**
+   * Get pixel domains (allowed domains for the pixel)
+   */
+  async getDomains(pixelId: string): Promise<string[]> {
+    const response = await this.client.get<{
+      request_status: string;
+      domains: { domain: string }[];
+    }>(`/pixels/${pixelId}/domains`);
+    return response.domains?.map(d => d.domain) || [];
+  }
+
+  /**
+   * Add a domain to a pixel
+   */
+  async addDomain(pixelId: string, domain: string): Promise<void> {
+    await this.client.post(`/pixels/${pixelId}/domains`, {
+      domains: [{ domain }],
+    });
+  }
+
+  /**
+   * Remove a domain from a pixel
+   */
+  async removeDomain(pixelId: string, domainId: string): Promise<void> {
+    await this.client.delete(`/pixels/${pixelId}/domains/${domainId}`);
+  }
+
+  /**
+   * Generate pixel base code for a website
+   */
+  generateBaseCode(pixelId: string): string {
+    return `<!-- Snap Pixel Code -->
+<script type='text/javascript'>
+(function(e,t,n){if(e.snaptr)return;var a=e.snaptr=function()
+{a.handleRequest?a.handleRequest.apply(a,arguments):a.queue.push(arguments)};
+a.queue=[];var s='script';r=t.createElement(s);r.async=!0;
+r.src=n;var u=t.getElementsByTagName(s)[0];
+u.parentNode.insertBefore(r,u);})(window,document,
+'https://sc-static.net/scevent.min.js');
+
+snaptr('init', '${pixelId}');
+snaptr('track', 'PAGE_VIEW');
+</script>
+<!-- End Snap Pixel Code -->`;
+  }
+
+  /**
+   * Generate event tracking code
+   */
+  generateEventCode(
+    eventType: string,
+    options?: {
+      price?: number;
+      currency?: string;
+      itemIds?: string[];
+      numberOfItems?: number;
+      transactionId?: string;
+      description?: string;
+    }
+  ): string {
+    const params: Record<string, unknown> = {};
+
+    if (options?.price) params.price = options.price;
+    if (options?.currency) params.currency = options.currency;
+    if (options?.itemIds) params.item_ids = options.itemIds;
+    if (options?.numberOfItems) params.number_items = options.numberOfItems;
+    if (options?.transactionId) params.transaction_id = options.transactionId;
+    if (options?.description) params.description = options.description;
+
+    const paramsStr = Object.keys(params).length > 0
+      ? `, ${JSON.stringify(params)}`
+      : '';
+
+    return `snaptr('track', '${eventType}'${paramsStr});`;
+  }
+
+  /**
+   * List supported pixel event types
+   */
+  getSupportedEventTypes(): string[] {
+    return [
+      'PAGE_VIEW',
+      'VIEW_CONTENT',
+      'ADD_CART',
+      'ADD_TO_WISHLIST',
+      'SIGN_UP',
+      'PURCHASE',
+      'SAVE',
+      'START_CHECKOUT',
+      'ADD_BILLING',
+      'SEARCH',
+      'SUBSCRIBE',
+      'AD_CLICK',
+      'AD_VIEW',
+      'COMPLETE_TUTORIAL',
+      'LEVEL_COMPLETE',
+      'INVITE',
+      'LOGIN',
+      'SHARE',
+      'RESERVE',
+      'ACHIEVEMENT_UNLOCKED',
+      'SPENT_CREDITS',
+      'RATE',
+      'START_TRIAL',
+      'LIST_VIEW',
+      'APP_OPEN',
+      'APP_INSTALL',
+      'CUSTOM_EVENT_1',
+      'CUSTOM_EVENT_2',
+      'CUSTOM_EVENT_3',
+      'CUSTOM_EVENT_4',
+      'CUSTOM_EVENT_5',
+    ];
+  }
+}