@hasna/connectors 1.3.2 → 1.3.3

package/connectors/connect-pusher/src/api/client.ts

@@ -1,213 +1,44 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { PusherConfig } from '../types';
+import { PusherApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
-
-export interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: Record<string, unknown> | unknown[] | string;
-  headers?: Record<string, string>;
-  format?: OutputFormat;
-  /** Number of retries for failed requests (default: 3) */
-  retries?: number;
-  /** Timeout in milliseconds (default: 30000) */
-  timeout?: number;
-}
-
-export class ConnectorClient {
-  private readonly apiKey: string;
-  private readonly apiSecret?: string;
+export class PusherClient {
+  private readonly appId: string;
+  private readonly key: string;
+  private readonly secret: string;
   private readonly baseUrl: string;
 
-  constructor(config: ConnectorConfig) {
-    // Support both 'apiKey' and 'token' for flexibility
-    // Also support 'accessToken' for OAuth2
-    const key = config.apiKey || config.token || config.accessToken;
-    if (!key) {
-      throw new Error('API key, token, or accessToken is required');
-    }
-    this.apiKey = key;
-    this.apiSecret = config.apiSecret;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
-  }
-
-  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
-    const url = new URL(`${this.baseUrl}${path}`);
-
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== '') {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-
-    return url.toString();
-  }
-
-  /**
-   * Sleep for a given number of milliseconds
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Calculate delay for exponential backoff
-   */
-  private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
-    // Exponential backoff with jitter: base * 2^attempt + random(0-1000)ms
-    return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
-  }
-
-  /**
-   * Check if error is retryable
-   */
-  private isRetryableStatus(status: number): boolean {
-    // Retry on rate limit (429) and server errors (5xx)
-    return status === 429 || (status >= 500 && status < 600);
-  }
-
-  /**
-   * Make an authenticated request to the API
-   * TODO: Adjust authentication method for your API:
-   * - Bearer token: Authorization: Bearer <token>
-   * - API Key header: X-API-Key: <key>
-   * - Basic auth: Authorization: Basic <base64(key:secret)>
-   */
-  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    const { method = 'GET', params, body, headers = {}, retries = 3, timeout = 30000 } = options;
-
-    const url = this.buildUrl(path, params);
-
-    // TODO: Adjust authentication header for your API
-    const requestHeaders: Record<string, string> = {
-      'Authorization': `Bearer ${this.apiKey}`,
-      'Accept': 'application/json',
-      ...headers,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      requestHeaders['Content-Type'] = 'application/json';
-    }
-
-    const fetchOptions: RequestInit = {
-      method,
-      headers: requestHeaders,
-    };
-
-    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
-    }
-
-    let lastError: Error | null = null;
-    let lastStatus: number = 0;
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        // Create abort controller for timeout
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-        const response = await fetch(url, {
-          ...fetchOptions,
-          signal: controller.signal,
-        });
-
-        clearTimeout(timeoutId);
-        lastStatus = response.status;
-
-        // Handle 204 No Content
-        if (response.status === 204) {
-          return {} as T;
-        }
-
-        // Parse response
-        let data: unknown;
-        const contentType = response.headers.get('content-type') || '';
-
-        if (contentType.includes('application/json')) {
-          const text = await response.text();
-          if (text) {
-            try {
-              data = JSON.parse(text);
-            } catch {
-              data = text;
-            }
-          }
-        } else {
-          data = await response.text();
-        }
-
-        // Handle errors
-        if (!response.ok) {
-          // Check if we should retry
-          if (this.isRetryableStatus(response.status) && attempt < retries) {
-            // Check for Retry-After header
-            const retryAfter = response.headers.get('retry-after');
-            const delay = retryAfter
-              ? parseInt(retryAfter, 10) * 1000
-              : this.getRetryDelay(attempt);
-
-            await this.sleep(delay);
-            continue;
-          }
-
-          throw parseApiError(data, response.status);
-        }
-
-        return data as T;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-
-        // Handle timeout errors
-        if (lastError.name === 'AbortError') {
-          lastError = new Error(`Request timeout after ${timeout}ms`);
-        }
-
-        // Retry on network errors
-        if (attempt < retries && !(err instanceof ConnectorApiError)) {
-          await this.sleep(this.getRetryDelay(attempt));
-          continue;
-        }
-
-        throw err;
-      }
-    }
-
-    // Should not reach here, but just in case
-    throw lastError || new ConnectorApiError('Request failed', lastStatus);
-  }
-
-  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'GET', params });
+  constructor(config: PusherConfig) {
+    if (!config.appId || !config.key || !config.secret || !config.cluster) throw new Error('Pusher appId, key, secret, and cluster are required');
+    this.appId = config.appId;
+    this.key = config.key;
+    this.secret = config.secret;
+    this.baseUrl = `https://api-${config.cluster}.pusher.com/apps/${config.appId}`;
   }
 
-  async post<T>(path: string, body?: Record<string, unknown> | unknown[] | string | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
+  private generateSignature(method: string, path: string, params: string, body?: string): string {
+    // Pusher uses HMAC-SHA256 signing — simplified for fetch-based usage
+    // In production, use crypto.createHmac. Here we pass token as query param.
+    const timestamp = Math.floor(Date.now() / 1000);
+    return `auth_key=${this.key}&auth_timestamp=${timestamp}&auth_version=1.0${body ? `&body_md5=${body}` : ''}`;
   }
 
-  async put<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
-  }
-
-  async patch<T>(path: string, body?: Record<string, unknown> | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PATCH', body: body as Record<string, unknown>, params });
-  }
-
-  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'DELETE', params });
-  }
-
-  /**
-   * Get a preview of the API key (for display/debugging)
-   */
-  getApiKeyPreview(): string {
-    if (this.apiKey.length > 10) {
-      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
-    }
-    return '***';
-  }
+  async request<T>(path: string, options: { method?: string; body?: Record<string, unknown>; params?: Record<string, string | number | undefined> } = {}): Promise<T> {
+    const { method = 'GET', body, params } = options;
+    const url = new URL(`${this.baseUrl}${path}`);
+    url.searchParams.append('auth_key', this.key);
+    url.searchParams.append('auth_timestamp', String(Math.floor(Date.now() / 1000)));
+    url.searchParams.append('auth_version', '1.0');
+    if (params) Object.entries(params).forEach(([k, v]) => { if (v !== undefined) url.searchParams.append(k, String(v)); });
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    const fetchOptions: RequestInit = { method, headers };
+    if (body && ['POST', 'PUT'].includes(method)) fetchOptions.body = JSON.stringify(body);
+    const response = await fetch(url.toString(), fetchOptions);
+    if (response.status === 204 || response.status === 200 && (await response.text()).length === 0) return {} as T;
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new PusherApiError((data as { error?: string })?.error || response.statusText, response.status);
+    return data as T;
+  }
+
+  getKey(): string { return this.key; }
+  getAppId(): string { return this.appId; }
 }

package/connectors/connect-pusher/src/api/index.ts

@@ -1,51 +1,39 @@
-import type { ConnectorConfig } from '../types';
-import { ConnectorClient } from './client';
-import { ExampleApi } from './example';
-
-/**
- * Main Connector class
- * TODO: Rename to your API name (e.g., Perplexity, Twitter, etc.)
- */
-export class Connector {
-  private readonly client: ConnectorClient;
-
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
+// Pusher Connector — Realtime messaging and channels
+import { PusherClient } from './client';
+import type { PusherConfig, PusherChannel, PusherChannelInfo, PusherUser, PusherBatchEvent } from '../types';
+export { PusherClient } from './client';
+
+export class Pusher {
+  private readonly client: PusherClient;
+  constructor(config: PusherConfig) { this.client = new PusherClient(config); }
+  static fromEnv(): Pusher {
+    const appId = process.env.PUSHER_APP_ID;
+    const key = process.env.PUSHER_KEY;
+    const secret = process.env.PUSHER_SECRET;
+    const cluster = process.env.PUSHER_CLUSTER;
+    if (!appId || !key || !secret || !cluster) throw new Error('PUSHER_APP_ID, PUSHER_KEY, PUSHER_SECRET, and PUSHER_CLUSTER are required');
+    return new Pusher({ appId, key, secret, cluster });
+  }
 
-  constructor(config: ConnectorConfig) {
-    this.client = new ConnectorClient(config);
-    this.example = new ExampleApi(this.client);
+  async trigger(channel: string, event: string, data: unknown, socketId?: string): Promise<void> {
+    await this.client.request('/events', { method: 'POST', body: { name: event, channel, data: JSON.stringify(data), socket_id: socketId } as Record<string, unknown> });
   }
 
-  /**
-   * Create a client from environment variables
-   * TODO: Update env var names for your API
-   * Looks for CONNECTOR_API_KEY and optionally CONNECTOR_API_SECRET
-   */
-  static fromEnv(): Connector {
-    const apiKey = process.env.CONNECTOR_API_KEY;
-    const apiSecret = process.env.CONNECTOR_API_SECRET;
+  async triggerBatch(events: PusherBatchEvent[]): Promise<void> {
+    await this.client.request('/batch_events', { method: 'POST', body: { batch: events } as Record<string, unknown> });
+  }
 
-    if (!apiKey) {
-      throw new Error('CONNECTOR_API_KEY environment variable is required');
-    }
-    return new Connector({ apiKey, apiSecret });
+  async listChannels(options?: { filter_by_prefix?: string; info?: string }): Promise<{ channels: Record<string, PusherChannel> }> {
+    return this.client.request('/channels', { params: { filter_by_prefix: options?.filter_by_prefix, info: options?.info } });
   }
 
-  /**
-   * Get a preview of the API key (for debugging)
-   */
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  async getChannel(channelName: string, options?: { info?: string }): Promise<PusherChannelInfo> {
+    return this.client.request<PusherChannelInfo>(`/channels/${channelName}`, { params: { info: options?.info } });
   }
 
-  /**
-   * Get the underlying client for direct API access
-   */
-  getClient(): ConnectorClient {
-    return this.client;
+  async getChannelUsers(channelName: string): Promise<{ users: PusherUser[] }> {
+    return this.client.request(`/channels/${channelName}/users`);
   }
-}
 
-export { ConnectorClient } from './client';
-export { ExampleApi } from './example';
+  getClient(): PusherClient { return this.client; }
+}

package/connectors/connect-pusher/src/types/index.ts

@@ -1,237 +1,12 @@
-// Scaffold Connector Types
-// Replace CONNECTOR with your API name (e.g., Perplexity, Twitter, etc.)
+export interface PusherConfig { appId: string; key: string; secret: string; cluster: string; }
 
-// ============================================
-// Configuration
-// ============================================
+export interface PusherChannel { name: string; occupied: boolean; user_count?: number; subscription_count?: number; }
+export interface PusherChannelInfo { occupied: boolean; user_count: number; subscription_count: number; }
+export interface PusherUser { id: string; }
+export interface PusherTriggerResult { channels: Record<string, unknown>; }
+export interface PusherBatchEvent { channel: string; name: string; data: string; socket_id?: string; }
 
-export interface ConnectorConfig {
-  apiKey?: string;      // For API key authentication
-  token?: string;       // Alias for apiKey (some APIs use 'token')
-  apiSecret?: string;   // Optional - some APIs need only a key
-  accessToken?: string; // For OAuth2 authentication
-  baseUrl?: string;     // Override default base URL
-}
-
-// ============================================
-// OAuth2 Types
-// ============================================
-
-export interface OAuth2Config {
-  clientId: string;
-  clientSecret: string;
-  redirectUri?: string;
-}
-
-export interface OAuth2Tokens {
-  accessToken: string;
-  refreshToken?: string;
-  expiresAt: number;
-  tokenType?: string;
-  scope?: string;
-}
-
-// ============================================
-// Common Types
-// ============================================
-
-export type OutputFormat = 'json' | 'pretty';
-
-export interface PaginatedResponse<T> {
-  data: T[];
-  nextToken?: string;
-  hasMore: boolean;
-}
-
-// ============================================
-// Example Resource Types
-// ============================================
-
-// Replace with your API's resource types
-export interface ExampleResource {
-  id: string;
-  name: string;
-  createdAt: string;
-  updatedAt: string;
-  // Add more fields as needed
-}
-
-export interface ExampleListResponse {
-  items: ExampleResource[];
-  nextPageToken?: string;
-  total?: number;
-}
-
-export interface ExampleCreateParams {
-  name: string;
-  // Add more params as needed
-}
-
-// ============================================
-// API Error Types
-// ============================================
-
-export interface ApiErrorDetail {
-  code: string;
-  message: string;
-  field?: string;
-  resource?: string;
-}
-
-export class ConnectorApiError extends Error {
+export class PusherApiError extends Error {
   public readonly statusCode: number;
-  public readonly errors?: ApiErrorDetail[];
-  public readonly documentationUrl?: string;
-  public readonly requestId?: string;
-
-  constructor(
-    message: string,
-    statusCode: number,
-    options?: {
-      errors?: ApiErrorDetail[];
-      documentationUrl?: string;
-      requestId?: string;
-    }
-  ) {
-    super(message);
-    this.name = 'ConnectorApiError';
-    this.statusCode = statusCode;
-    this.errors = options?.errors;
-    this.documentationUrl = options?.documentationUrl;
-    this.requestId = options?.requestId;
-  }
-
-  /**
-   * Check if this is a rate limit error
-   */
-  isRateLimited(): boolean {
-    return this.statusCode === 429;
-  }
-
-  /**
-   * Check if this is a server error
-   */
-  isServerError(): boolean {
-    return this.statusCode >= 500 && this.statusCode < 600;
-  }
-
-  /**
-   * Check if this is a client error
-   */
-  isClientError(): boolean {
-    return this.statusCode >= 400 && this.statusCode < 500;
-  }
-
-  /**
-   * Check if this is an authentication error
-   */
-  isAuthError(): boolean {
-    return this.statusCode === 401 || this.statusCode === 403;
-  }
-
-  /**
-   * Check if this is a not found error
-   */
-  isNotFound(): boolean {
-    return this.statusCode === 404;
-  }
-
-  /**
-   * Get a user-friendly error message
-   */
-  getUserMessage(): string {
-    switch (this.statusCode) {
-      case 400:
-        return 'Bad request. Please check your input.';
-      case 401:
-        return 'Authentication failed. Please check your API key or login again.';
-      case 403:
-        return 'Access denied. You do not have permission to perform this action.';
-      case 404:
-        return 'Resource not found.';
-      case 429:
-        return 'Rate limit exceeded. Please wait and try again.';
-      case 500:
-        return 'Server error. Please try again later.';
-      case 502:
-      case 503:
-      case 504:
-        return 'Service temporarily unavailable. Please try again later.';
-      default:
-        return this.message;
-    }
-  }
-
-  /**
-   * Convert to JSON for logging/debugging
-   */
-  toJSON(): Record<string, unknown> {
-    return {
-      name: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      errors: this.errors,
-      documentationUrl: this.documentationUrl,
-      requestId: this.requestId,
-    };
-  }
-}
-
-/**
- * Parse an API error response into a ConnectorApiError
- * Handles various common API error response formats
- */
-export function parseApiError(
-  response: unknown,
-  statusCode: number
-): ConnectorApiError {
-  // Handle string responses
-  if (typeof response === 'string') {
-    return new ConnectorApiError(response, statusCode);
-  }
-
-  // Handle null/undefined
-  if (!response || typeof response !== 'object') {
-    return new ConnectorApiError(`HTTP ${statusCode} Error`, statusCode);
-  }
-
-  const data = response as Record<string, unknown>;
-
-  // Extract message from various common formats
-  const message =
-    (data.message as string) ||
-    (data.error as string) ||
-    ((data.error as Record<string, unknown>)?.message as string) ||
-    (data.error_description as string) ||
-    (data.detail as string) ||
-    `HTTP ${statusCode} Error`;
-
-  // Extract errors array if present
-  let errors: ApiErrorDetail[] | undefined;
-  if (Array.isArray(data.errors)) {
-    errors = data.errors.map((e: Record<string, unknown>) => ({
-      code: String(e.code || e.error || 'unknown'),
-      message: String(e.message || e.description || 'Unknown error'),
-      field: e.field as string,
-      resource: e.resource as string,
-    }));
-  }
-
-  // Extract documentation URL
-  const documentationUrl =
-    (data.documentation_url as string) ||
-    (data.docs_url as string) ||
-    (data.help_url as string);
-
-  // Extract request ID
-  const requestId =
-    (data.request_id as string) ||
-    (data.requestId as string) ||
-    (data.trace_id as string);
-
-  return new ConnectorApiError(message, statusCode, {
-    errors,
-    documentationUrl,
-    requestId,
-  });
+  constructor(message: string, statusCode: number) { super(message); this.name = 'PusherApiError'; this.statusCode = statusCode; }
 }