@hasna/connectors 1.3.3 → 1.3.5

package/connectors/connect-brandsight/src/api/brandsight.test.ts

@@ -0,0 +1,324 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import { ConnectorClient } from './client';
+import { MonitoringApi } from './monitoring';
+import { IntelligenceApi } from './intelligence';
+import { Connector } from './index';
+import { ConnectorApiError } from '../types';
+
+// ============================================
+// Client Tests
+// ============================================
+
+describe('ConnectorClient', () => {
+  test('requires apiKey', () => {
+    expect(() => new ConnectorClient({ apiKey: '' })).toThrow('API key is required');
+  });
+
+  test('creates client with valid config', () => {
+    const client = new ConnectorClient({ apiKey: 'test-key-1234567890' });
+    expect(client).toBeDefined();
+    expect(client.getApiKeyPreview()).toBe('test-k...7890');
+  });
+
+  test('builds correct URL', () => {
+    const client = new ConnectorClient({ apiKey: 'key' });
+    const url = client.buildUrl('/brands/acme/monitor');
+    expect(url).toBe('https://api.brandsight.com/v1/brands/acme/monitor');
+  });
+
+  test('getApiKeyPreview masks key', () => {
+    const client = new ConnectorClient({ apiKey: 'abcdef1234567890' });
+    expect(client.getApiKeyPreview()).toBe('abcdef...7890');
+  });
+
+  test('getApiKeyPreview returns *** for short key', () => {
+    const client = new ConnectorClient({ apiKey: '1234567890' });
+    expect(client.getApiKeyPreview()).toBe('***');
+  });
+
+  test('request returns stub when API unreachable', async () => {
+    const client = new ConnectorClient({ apiKey: 'test-key-12345' });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.reject(new Error('Network error'))
+    ) as any;
+
+    const result = await client.request('/brands/test/monitor');
+    expect(result.stub).toBe(true);
+    expect(result.data).toBeNull();
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('request throws ConnectorApiError on HTTP error', async () => {
+    const client = new ConnectorClient({ apiKey: 'test-key-12345' });
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('Unauthorized', { status: 401, statusText: 'Unauthorized' }))
+    ) as any;
+
+    await expect(client.request('/brands/test/monitor')).rejects.toThrow('Brandsight API GET');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('request returns parsed JSON on success', async () => {
+    const client = new ConnectorClient({ apiKey: 'test-key-12345' });
+    const mockData = { alerts: [{ domain: 'test.com', type: 'typosquat', registered_at: '2024-01-01' }] };
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify(mockData), { status: 200 }))
+    ) as any;
+
+    const result = await client.request('/brands/test/monitor');
+    expect(result.stub).toBe(false);
+    expect(result.data).toEqual(mockData);
+
+    globalThis.fetch = originalFetch;
+  });
+});
+
+// ============================================
+// Connector Tests
+// ============================================
+
+describe('Connector', () => {
+  test('creates connector with valid config', () => {
+    const connector = new Connector({ apiKey: 'key' });
+    expect(connector.monitoring).toBeDefined();
+    expect(connector.intelligence).toBeDefined();
+  });
+
+  test('fromEnv throws without BRANDSIGHT_API_KEY', () => {
+    const origKey = process.env.BRANDSIGHT_API_KEY;
+    delete process.env.BRANDSIGHT_API_KEY;
+
+    expect(() => Connector.fromEnv()).toThrow('BRANDSIGHT_API_KEY environment variable is required');
+
+    if (origKey) process.env.BRANDSIGHT_API_KEY = origKey;
+  });
+
+  test('fromEnv creates connector with env var', () => {
+    const origKey = process.env.BRANDSIGHT_API_KEY;
+    process.env.BRANDSIGHT_API_KEY = 'test-key-12345';
+
+    const connector = Connector.fromEnv();
+    expect(connector).toBeDefined();
+    expect(connector.getApiKeyPreview()).toBe('test-k...2345');
+
+    if (origKey) process.env.BRANDSIGHT_API_KEY = origKey; else delete process.env.BRANDSIGHT_API_KEY;
+  });
+
+  test('getClient returns the underlying client', () => {
+    const connector = new Connector({ apiKey: 'key' });
+    const client = connector.getClient();
+    expect(client).toBeInstanceOf(ConnectorClient);
+  });
+});
+
+// ============================================
+// MonitoringApi Tests
+// ============================================
+
+describe('MonitoringApi', () => {
+  let client: ConnectorClient;
+  let monitoringApi: MonitoringApi;
+
+  beforeEach(() => {
+    client = new ConnectorClient({ apiKey: 'test-key-12345' });
+    monitoringApi = new MonitoringApi(client);
+  });
+
+  test('monitorBrand returns live data on success', async () => {
+    const mockResponse = {
+      alerts: [
+        { domain: 'acme-deals.com', type: 'keyword', registered_at: '2024-01-01T00:00:00Z' },
+      ],
+    };
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 }))
+    ) as any;
+
+    const result = await monitoringApi.monitorBrand('acme');
+    expect(result.brand).toBe('acme');
+    expect(result.stub).toBe(false);
+    expect(result.alerts).toHaveLength(1);
+    expect(result.alerts[0].domain).toBe('acme-deals.com');
+    expect(result.alerts[0].type).toBe('keyword');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('monitorBrand returns stub data when API unreachable', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.reject(new Error('Network error'))
+    ) as any;
+
+    const result = await monitoringApi.monitorBrand('acme');
+    expect(result.brand).toBe('acme');
+    expect(result.stub).toBe(true);
+    expect(result.alerts.length).toBeGreaterThan(0);
+    // Stub alerts should reference the brand name
+    expect(result.alerts[0].domain).toContain('acme');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getSimilarDomains returns live data on success', async () => {
+    const mockResponse = {
+      similar: ['acme-online.com', 'acmes.com', '4cm3.com'],
+    };
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 }))
+    ) as any;
+
+    const result = await monitoringApi.getSimilarDomains('acme.com');
+    expect(result.domain).toBe('acme.com');
+    expect(result.stub).toBe(false);
+    expect(result.similar).toHaveLength(3);
+    expect(result.similar).toContain('acme-online.com');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getSimilarDomains returns stub data when API unreachable', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.reject(new Error('Network error'))
+    ) as any;
+
+    const result = await monitoringApi.getSimilarDomains('acme.com');
+    expect(result.domain).toBe('acme.com');
+    expect(result.stub).toBe(true);
+    expect(result.similar.length).toBeGreaterThan(0);
+
+    globalThis.fetch = originalFetch;
+  });
+});
+
+// ============================================
+// IntelligenceApi Tests
+// ============================================
+
+describe('IntelligenceApi', () => {
+  let client: ConnectorClient;
+  let intelligenceApi: IntelligenceApi;
+
+  beforeEach(() => {
+    client = new ConnectorClient({ apiKey: 'test-key-12345' });
+    intelligenceApi = new IntelligenceApi(client);
+  });
+
+  test('getWhoisHistory returns live data on success', async () => {
+    const mockResponse = {
+      history: [
+        { registrant: 'Acme Inc', date: '2024-01-01T00:00:00Z', changes: ['initial_registration'] },
+      ],
+    };
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 }))
+    ) as any;
+
+    const result = await intelligenceApi.getWhoisHistory('acme.com');
+    expect(result.domain).toBe('acme.com');
+    expect(result.stub).toBe(false);
+    expect(result.history).toHaveLength(1);
+    expect(result.history[0].registrant).toBe('Acme Inc');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getWhoisHistory returns stub data when API unreachable', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.reject(new Error('Network error'))
+    ) as any;
+
+    const result = await intelligenceApi.getWhoisHistory('acme.com');
+    expect(result.domain).toBe('acme.com');
+    expect(result.stub).toBe(true);
+    expect(result.history.length).toBeGreaterThan(0);
+    expect(result.history[0].registrant).toBe('Privacy Proxy Service');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getThreatAssessment returns live data on success', async () => {
+    const mockResponse = {
+      domain: 'suspicious.com',
+      risk_level: 'high',
+      threats: ['phishing', 'malware'],
+      recommendation: 'Take down immediately',
+    };
+
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 }))
+    ) as any;
+
+    const result = await intelligenceApi.getThreatAssessment('suspicious.com');
+    expect(result.domain).toBe('suspicious.com');
+    expect(result.stub).toBe(false);
+    expect(result.risk_level).toBe('high');
+    expect(result.threats).toContain('phishing');
+    expect(result.recommendation).toBe('Take down immediately');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getThreatAssessment returns stub data when API unreachable', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.reject(new Error('Network error'))
+    ) as any;
+
+    const result = await intelligenceApi.getThreatAssessment('acme.com');
+    expect(result.domain).toBe('acme.com');
+    expect(result.stub).toBe(true);
+    expect(result.risk_level).toBe('low');
+    expect(result.threats).toHaveLength(0);
+    expect(result.recommendation).toContain('No immediate threats');
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test('getThreatAssessment throws on HTTP 500', async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() =>
+      Promise.resolve(new Response('Internal Server Error', { status: 500, statusText: 'Internal Server Error' }))
+    ) as any;
+
+    await expect(intelligenceApi.getThreatAssessment('acme.com')).rejects.toThrow('Brandsight API GET');
+
+    globalThis.fetch = originalFetch;
+  });
+});
+
+// ============================================
+// ConnectorApiError Tests
+// ============================================
+
+describe('ConnectorApiError', () => {
+  test('creates error with message and status code', () => {
+    const err = new ConnectorApiError('test error', 500);
+    expect(err.message).toBe('test error');
+    expect(err.statusCode).toBe(500);
+    expect(err.name).toBe('ConnectorApiError');
+  });
+
+  test('creates error with response body', () => {
+    const err = new ConnectorApiError('unauthorized', 401, '{"error":"invalid_key"}');
+    expect(err.responseBody).toBe('{"error":"invalid_key"}');
+    expect(err.statusCode).toBe(401);
+  });
+});

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

@@ -1,167 +1,71 @@
-import type { BrandsightConfig, OutputFormat } from '../types';
-import { BrandsightApiError } from '../types';
+import type { ConnectorConfig } from '../types';
+import { ConnectorApiError } from '../types';
 
-// GoDaddy/Brandsight API base URLs
-const DEFAULT_BASE_URL = 'https://api.godaddy.com';
-const OTE_BASE_URL = 'https://api.ote-godaddy.com'; // Testing environment
+// Brandsight API base URL
+const API_BASE = 'https://api.brandsight.com/v1';
 
-export interface RequestOptions {
-  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
-  params?: Record<string, string | number | boolean | undefined>;
-  body?: Record<string, unknown> | unknown[];
-  headers?: Record<string, string>;
-  format?: OutputFormat;
-}
-
-export class BrandsightClient {
+/**
+ * Low-level HTTP client for the Brandsight REST API.
+ * Handles URL building, Bearer auth, and JSON error checking.
+ */
+export class ConnectorClient {
   private readonly apiKey: string;
-  private readonly apiSecret: string;
-  private readonly customerId?: string;
   private readonly baseUrl: string;
 
-  constructor(config: BrandsightConfig) {
+  constructor(config: ConnectorConfig) {
     if (!config.apiKey) {
       throw new Error('API key is required');
     }
-    if (!config.apiSecret) {
-      throw new Error('API secret is required');
-    }
     this.apiKey = config.apiKey;
-    this.apiSecret = config.apiSecret;
-    this.customerId = config.customerId;
-    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.baseUrl = API_BASE;
   }
 
-  getCustomerId(): string | undefined {
-    return this.customerId;
+  /**
+   * Build a full Brandsight API URL for a given path
+   */
+  buildUrl(path: string): string {
+    return `${this.baseUrl}${path}`;
   }
 
-  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));
-        }
+  /**
+   * Make an authenticated GET request to the Brandsight API.
+   * Returns parsed JSON on success, or { stub: true } when API is unreachable.
+   */
+  async request<T>(path: string): Promise<{ data: T; stub: false } | { data: null; stub: true }> {
+    const url = this.buildUrl(path);
+
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+          'User-Agent': 'connect-brandsight/0.1.0',
+        },
+        signal: AbortSignal.timeout(15000),
       });
-    }
-
-    return url.toString();
-  }
-
-  private getAcceptHeader(format: OutputFormat = 'json'): string {
-    return format === 'xml' ? 'application/xml' : 'application/json';
-  }
-
-  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    const { method = 'GET', params, body, headers = {}, format = 'json' } = options;
-
-    const url = this.buildUrl(path, params);
 
-    // Brandsight/GoDaddy uses sso-key authentication
-    const requestHeaders: Record<string, string> = {
-      'Authorization': `sso-key ${this.apiKey}:${this.apiSecret}`,
-      'Accept': this.getAcceptHeader(format),
-      ...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 = JSON.stringify(body);
-    }
-
-    const response = await fetch(url, fetchOptions);
-
-    // Handle HEAD requests (status check)
-    if (method === 'HEAD') {
-      return {
-        active: response.status === 204 || response.status === 200,
-        statusCode: response.status
-      } as T;
-    }
-
-    // Handle 204 No Content
-    if (response.status === 204) {
-      return {} as T;
-    }
-
-    // Handle partial content (pagination)
-    const hasMore = response.status === 206;
-
-    // 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;
-        }
+      if (!response.ok) {
+        throw new ConnectorApiError(
+          `Brandsight API GET ${path} failed with status ${response.status}`,
+          response.status,
+          await response.text()
+        );
       }
-    } else if (contentType.includes('application/xml')) {
-      data = await response.text();
-    } else {
-      const text = await response.text();
-      try {
-        data = JSON.parse(text);
-      } catch {
-        data = text;
-      }
-    }
 
-    // Handle errors
-    if (!response.ok && response.status !== 206) {
-      const errorMessage = typeof data === 'object' && data !== null
-        ? JSON.stringify(data)
-        : String(data || response.statusText);
-      throw new BrandsightApiError(errorMessage, response.status);
+      const data = (await response.json()) as T;
+      return { data, stub: false };
+    } catch (error) {
+      if (error instanceof ConnectorApiError) throw error;
+      // API unreachable — return stub indicator
+      return { data: null, stub: true };
     }
-
-    // Add pagination info if needed
-    if (hasMore && typeof data === 'object' && data !== null) {
-      (data as Record<string, unknown>)._hasMore = true;
-    }
-
-    return data as T;
-  }
-
-  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>, format?: OutputFormat): Promise<T> {
-    return this.request<T>(path, { method: 'GET', params, format });
-  }
-
-  async post<T>(path: string, body?: Record<string, unknown> | unknown[], params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'POST', body, params });
-  }
-
-  async put<T>(path: string, body?: Record<string, unknown>, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PUT', body, params });
-  }
-
-  async patch<T>(path: string, body?: Record<string, unknown>, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'PATCH', body, params });
-  }
-
-  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'DELETE', params });
-  }
-
-  async head<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
-    return this.request<T>(path, { method: 'HEAD', params });
   }
 
-  // Utility to get API key preview (for display/debugging)
+  /**
+   * 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)}`;

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

@@ -1,34 +1,36 @@
-import type { BrandsightConfig } from '../types';
-import { BrandsightClient } from './client';
-import { DomainsApi } from './domains';
+import type { ConnectorConfig } from '../types';
+import { ConnectorClient } from './client';
+import { MonitoringApi } from './monitoring';
+import { IntelligenceApi } from './intelligence';
 
-export class Brandsight {
-  private readonly client: BrandsightClient;
+/**
+ * Brandsight API Connector class
+ */
+export class Connector {
+  private readonly client: ConnectorClient;
 
   // API modules
-  public readonly domains: DomainsApi;
+  public readonly monitoring: MonitoringApi;
+  public readonly intelligence: IntelligenceApi;
 
-  constructor(config: BrandsightConfig) {
-    this.client = new BrandsightClient(config);
-    this.domains = new DomainsApi(this.client);
+  constructor(config: ConnectorConfig) {
+    this.client = new ConnectorClient(config);
+    this.monitoring = new MonitoringApi(this.client);
+    this.intelligence = new IntelligenceApi(this.client);
   }
 
   /**
-   * Create a Brandsight client from environment variables
-   * Looks for BRANDSIGHT_API_KEY, BRANDSIGHT_API_SECRET, and optionally BRANDSIGHT_CUSTOMER_ID
+   * Create a client from environment variables
+   * Looks for BRANDSIGHT_API_KEY
    */
-  static fromEnv(): Brandsight {
+  static fromEnv(): Connector {
     const apiKey = process.env.BRANDSIGHT_API_KEY;
-    const apiSecret = process.env.BRANDSIGHT_API_SECRET;
-    const customerId = process.env.BRANDSIGHT_CUSTOMER_ID;
 
     if (!apiKey) {
       throw new Error('BRANDSIGHT_API_KEY environment variable is required');
     }
-    if (!apiSecret) {
-      throw new Error('BRANDSIGHT_API_SECRET environment variable is required');
-    }
-    return new Brandsight({ apiKey, apiSecret, customerId });
+
+    return new Connector({ apiKey });
   }
 
   /**
@@ -41,10 +43,12 @@ export class Brandsight {
   /**
    * Get the underlying client for direct API access
    */
-  getClient(): BrandsightClient {
+  getClient(): ConnectorClient {
     return this.client;
   }
 }
 
-export { BrandsightClient } from './client';
-export { DomainsApi } from './domains';
+// Export client and all API classes
+export { ConnectorClient } from './client';
+export { MonitoringApi } from './monitoring';
+export { IntelligenceApi } from './intelligence';

package/connectors/connect-brandsight/src/api/intelligence.ts

@@ -0,0 +1,82 @@
+import type { ConnectorClient } from './client';
+import type { WhoisRecord, WhoisHistoryResult, ThreatAssessment } from '../types';
+
+// ============================================
+// Stub Data Generators
+// ============================================
+
+function generateStubWhoisHistory(_domain: string): WhoisRecord[] {
+  return [
+    {
+      registrant: 'Privacy Proxy Service',
+      date: '2023-01-15T00:00:00Z',
+      changes: ['registrant_changed', 'nameserver_changed'],
+    },
+    {
+      registrant: 'Original Owner LLC',
+      date: '2020-06-01T00:00:00Z',
+      changes: ['initial_registration'],
+    },
+  ];
+}
+
+function generateStubThreatAssessment(domain: string): Omit<ThreatAssessment, 'stub'> {
+  return {
+    domain,
+    risk_level: 'low',
+    threats: [],
+    recommendation: 'No immediate threats detected. Continue routine monitoring.',
+  };
+}
+
+/**
+ * Brandsight Intelligence API
+ * Endpoints: /domains/:domain/whois-history, /domains/:domain/threats
+ */
+export class IntelligenceApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  /**
+   * Get historical WHOIS records for a domain.
+   */
+  async getWhoisHistory(domain: string): Promise<WhoisHistoryResult> {
+    const result = await this.client.request<{ history: WhoisRecord[] }>(
+      `/domains/${encodeURIComponent(domain)}/whois-history`
+    );
+
+    if (result.stub) {
+      return {
+        domain,
+        history: generateStubWhoisHistory(domain),
+        stub: true,
+      };
+    }
+
+    return {
+      domain,
+      history: result.data!.history,
+      stub: false,
+    };
+  }
+
+  /**
+   * Get a threat assessment for a domain.
+   */
+  async getThreatAssessment(domain: string): Promise<ThreatAssessment> {
+    const result = await this.client.request<Omit<ThreatAssessment, 'stub'>>(
+      `/domains/${encodeURIComponent(domain)}/threats`
+    );
+
+    if (result.stub) {
+      return {
+        ...generateStubThreatAssessment(domain),
+        stub: true,
+      };
+    }
+
+    return {
+      ...result.data!,
+      stub: false,
+    };
+  }
+}