@hasna/connectors 1.3.2 → 1.3.5

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

@@ -1,237 +1,12 @@
-// Scaffold Connector Types
-// Replace CONNECTOR with your API name (e.g., Perplexity, Twitter, etc.)
+export interface LambdaTestConfig { username: string; accessKey: string; }
 
-// ============================================
-// Configuration
-// ============================================
+export interface LTBuild { build_id: string; name: string; status_ind: string; start_timestamp: string; end_timestamp: string | null; user_id: number; }
+export interface LTSession { session_id: string; build_id: string; name: string; status_ind: string; browser: string; version: string; os: string; os_version: string; resolution: string; duration: number; start_timestamp: string; end_timestamp: string | null; test_type: string; }
+export interface LTSessionList { data: LTSession[]; Meta: { total: number; offset: number; limit: number }; }
+export interface LTTunnel { tunnel_id: string; tunnel_name: string; status: string; }
+export interface LTPlatform { platform: string; browsers: { browser_name: string; version: 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 LambdaTestApiError 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 = 'LambdaTestApiError'; this.statusCode = statusCode; }
 }

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

@@ -1,213 +1,26 @@
-import type { ConnectorConfig, OutputFormat } from '../types';
-import { ConnectorApiError, parseApiError } from '../types';
+import type { LapostaConfig } from '../types';
+import { LapostaApiError } from '../types';
 
-// TODO: Replace with your API's base URL
-const DEFAULT_BASE_URL = 'https://api.example.com';
+export class LapostaClient {
+  private readonly authHeader: string;
+  private readonly baseUrl = 'https://api.laposta.nl/v2';
 
-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;
-  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;
+  constructor(config: LapostaConfig) {
+    if (!config.apiKey) throw new Error('Laposta apiKey is required');
+    this.authHeader = `Basic ${btoa(`${config.apiKey}:`)}`;
   }
 
-  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+  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}`);
-
-    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 });
-  }
-
-  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 '***';
+    if (params) Object.entries(params).forEach(([k, v]) => { if (v !== undefined) url.searchParams.append(k, String(v)); });
+    const headers: Record<string, string> = { Authorization: this.authHeader, 'Content-Type': 'application/json' };
+    const fetchOptions: RequestInit = { method, headers };
+    if (body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) fetchOptions.body = JSON.stringify(body);
+    const response = await fetch(url.toString(), fetchOptions);
+    if (response.status === 204) return {} as T;
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new LapostaApiError((data as { error?: { message?: string } })?.error?.message || response.statusText, response.status);
+    return data as T;
   }
 }

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

@@ -1,51 +1,48 @@
-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;
+// Laposta Connector — Email marketing and newsletter platform
+import { LapostaClient } from './client';
+import type { LapostaConfig, LPList, LPMember, LPMemberList, LPCampaign, LPWebhook } from '../types';
+export { LapostaClient } from './client';
+
+export class Laposta {
+  private readonly client: LapostaClient;
+  constructor(config: LapostaConfig) { this.client = new LapostaClient(config); }
+  static fromEnv(): Laposta {
+    const apiKey = process.env.LAPOSTA_API_KEY;
+    if (!apiKey) throw new Error('LAPOSTA_API_KEY is required');
+    return new Laposta({ apiKey });
+  }
 
-  // API modules - add more as needed
-  public readonly example: ExampleApi;
+  async listLists(): Promise<{ data: { list: LPList }[] }> { return this.client.request('/list'); }
+  async getList(listId: string): Promise<{ list: LPList }> { return this.client.request(`/list/${listId}`); }
+  async createList(name: string, remarks?: string): Promise<{ list: LPList }> {
+    return this.client.request('/list', { method: 'POST', body: { name, remarks } });
+  }
+  async deleteList(listId: string): Promise<void> { await this.client.request(`/list/${listId}`, { method: 'DELETE' }); }
 
-  constructor(config: ConnectorConfig) {
-    this.client = new ConnectorClient(config);
-    this.example = new ExampleApi(this.client);
+  async listMembers(listId: string): Promise<LPMemberList> {
+    return this.client.request<LPMemberList>('/member', { params: { list_id: listId } });
+  }
+  async getMember(listId: string, memberId: string): Promise<{ member: LPMember }> {
+    return this.client.request(`/member/${memberId}`, { params: { list_id: listId } });
+  }
+  async addMember(listId: string, email: string, customFields?: Record<string, string>): Promise<{ member: LPMember }> {
+    return this.client.request('/member', { method: 'POST', body: { list_id: listId, email, custom_fields: customFields } as Record<string, unknown> });
+  }
+  async updateMember(listId: string, memberId: string, data: { email?: string; custom_fields?: Record<string, string> }): Promise<{ member: LPMember }> {
+    return this.client.request(`/member/${memberId}`, { method: 'POST', body: { list_id: listId, ...data } as Record<string, unknown> });
+  }
+  async deleteMember(listId: string, memberId: string): Promise<void> {
+    await this.client.request(`/member/${memberId}`, { method: 'DELETE', body: { list_id: listId } });
   }
 
-  /**
-   * 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 listCampaigns(): Promise<{ data: { campaign: LPCampaign }[] }> { return this.client.request('/campaign'); }
 
-    if (!apiKey) {
-      throw new Error('CONNECTOR_API_KEY environment variable is required');
-    }
-    return new Connector({ apiKey, apiSecret });
+  async listWebhooks(listId: string): Promise<{ data: { webhook: LPWebhook }[] }> {
+    return this.client.request('/webhook', { params: { list_id: listId } });
   }
-
-  /**
-   * Get a preview of the API key (for debugging)
-   */
-  getApiKeyPreview(): string {
-    return this.client.getApiKeyPreview();
+  async createWebhook(listId: string, event: string, url: string): Promise<{ webhook: LPWebhook }> {
+    return this.client.request('/webhook', { method: 'POST', body: { list_id: listId, event, url } });
   }
 
-  /**
-   * Get the underlying client for direct API access
-   */
-  getClient(): ConnectorClient {
-    return this.client;
-  }
+  getClient(): LapostaClient { return this.client; }
 }
-
-export { ConnectorClient } from './client';
-export { ExampleApi } from './example';