@hasna/connectors 0.4.2 → 0.5.1

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

@@ -0,0 +1,203 @@
+import type { ConnectorConfig, OutputFormat } from '../types';
+import { ConnectorApiError, parseApiError } from '../types';
+
+const DEFAULT_BASE_URL = 'https://rest.ably.io';
+
+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 baseUrl: string;
+
+  constructor(config: ConnectorConfig) {
+    const key = config.apiKey || config.token || config.accessToken;
+    if (!key) {
+      throw new Error('Ably API key is required (format: appId.keyId:keySecret)');
+    }
+    this.apiKey = key;
+    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 Ably REST API
+   */
+  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);
+
+    const requestHeaders: Record<string, string> = {
+      'Authorization': `Basic ${btoa(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 });
+  }
+
+  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 });
+  }
+
+  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 '***';
+  }
+}

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

@@ -0,0 +1,59 @@
+import type { ConnectorConfig } from '../types';
+import { ConnectorClient } from './client';
+import { MessagesApi } from './messages';
+import { ChannelsApi } from './channels';
+import { PresenceApi } from './presence';
+import { StatsApi } from './stats';
+
+/**
+ * Ably REST API Connector
+ */
+export class Connector {
+  private readonly client: ConnectorClient;
+
+  public readonly messages: MessagesApi;
+  public readonly channels: ChannelsApi;
+  public readonly presence: PresenceApi;
+  public readonly stats: StatsApi;
+
+  constructor(config: ConnectorConfig) {
+    this.client = new ConnectorClient(config);
+    this.messages = new MessagesApi(this.client);
+    this.channels = new ChannelsApi(this.client);
+    this.presence = new PresenceApi(this.client);
+    this.stats = new StatsApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for ABLY_API_KEY
+   */
+  static fromEnv(): Connector {
+    const apiKey = process.env.ABLY_API_KEY;
+
+    if (!apiKey) {
+      throw new Error('ABLY_API_KEY environment variable is required');
+    }
+    return new Connector({ apiKey });
+  }
+
+  /**
+   * Get a preview of the API key (for debugging)
+   */
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): ConnectorClient {
+    return this.client;
+  }
+}
+
+export { ConnectorClient } from './client';
+export { MessagesApi } from './messages';
+export { ChannelsApi } from './channels';
+export { PresenceApi } from './presence';
+export { StatsApi } from './stats';

package/connectors/connect-ably/src/api/messages.ts

@@ -0,0 +1,48 @@
+import type { ConnectorClient } from './client';
+import type {
+  Message,
+  PublishMessageParams,
+  PublishMessageResult,
+  MessageHistoryParams,
+} from '../types';
+
+export class MessagesApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  /**
+   * Publish a message to a channel
+   * POST /channels/{channelId}/messages
+   */
+  async publish(channelId: string, params: PublishMessageParams): Promise<PublishMessageResult> {
+    const body: Record<string, unknown> = {};
+    if (params.name !== undefined) body.name = params.name;
+    if (params.data !== undefined) body.data = params.data;
+    if (params.id !== undefined) body.id = params.id;
+    if (params.clientId !== undefined) body.clientId = params.clientId;
+    if (params.extras !== undefined) body.extras = params.extras;
+
+    await this.client.post(`/channels/${encodeURIComponent(channelId)}/messages`, body);
+
+    return {
+      channel: channelId,
+      messageId: params.id || '',
+    };
+  }
+
+  /**
+   * Get message history for a channel
+   * GET /channels/{channelId}/messages
+   */
+  async history(channelId: string, params?: MessageHistoryParams): Promise<Message[]> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {};
+    if (params?.start) queryParams.start = params.start;
+    if (params?.end) queryParams.end = params.end;
+    if (params?.limit) queryParams.limit = params.limit;
+    if (params?.direction) queryParams.direction = params.direction;
+
+    return this.client.get<Message[]>(
+      `/channels/${encodeURIComponent(channelId)}/messages`,
+      queryParams,
+    );
+  }
+}

package/connectors/connect-ably/src/api/presence.ts

@@ -0,0 +1,39 @@
+import type { ConnectorClient } from './client';
+import type { PresenceMember, PresenceParams, PresenceHistoryParams } from '../types';
+
+export class PresenceApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  /**
+   * Get current presence members for a channel
+   * GET /channels/{channelId}/presence
+   */
+  async get(channelId: string, params?: PresenceParams): Promise<PresenceMember[]> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {};
+    if (params?.clientId) queryParams.clientId = params.clientId;
+    if (params?.connectionId) queryParams.connectionId = params.connectionId;
+    if (params?.limit) queryParams.limit = params.limit;
+
+    return this.client.get<PresenceMember[]>(
+      `/channels/${encodeURIComponent(channelId)}/presence`,
+      queryParams,
+    );
+  }
+
+  /**
+   * Get presence history for a channel
+   * GET /channels/{channelId}/presence/history
+   */
+  async history(channelId: string, params?: PresenceHistoryParams): Promise<PresenceMember[]> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {};
+    if (params?.start) queryParams.start = params.start;
+    if (params?.end) queryParams.end = params.end;
+    if (params?.limit) queryParams.limit = params.limit;
+    if (params?.direction) queryParams.direction = params.direction;
+
+    return this.client.get<PresenceMember[]>(
+      `/channels/${encodeURIComponent(channelId)}/presence/history`,
+      queryParams,
+    );
+  }
+}

package/connectors/connect-ably/src/api/stats.ts

@@ -0,0 +1,29 @@
+import type { ConnectorClient } from './client';
+import type { Stats, StatsParams } from '../types';
+
+export class StatsApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  /**
+   * Get application statistics
+   * GET /stats
+   */
+  async get(params?: StatsParams): Promise<Stats[]> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {};
+    if (params?.start) queryParams.start = params.start;
+    if (params?.end) queryParams.end = params.end;
+    if (params?.limit) queryParams.limit = params.limit;
+    if (params?.direction) queryParams.direction = params.direction;
+    if (params?.unit) queryParams.unit = params.unit;
+
+    return this.client.get<Stats[]>('/stats', queryParams);
+  }
+
+  /**
+   * Get server time
+   * GET /time
+   */
+  async time(): Promise<number[]> {
+    return this.client.get<number[]>('/time');
+  }
+}