TYPESCRIPT connectors.ts

import api from './client';

export type ConfigField = {
  name: string;
  label: string;
  type: 'select' | 'text' | 'password';
  options?: string[];
  required: boolean;
};

export type ConnectorDef = {
  service: string;
  name: string;
  category: string;
  description: string;
  auth_type: string;
  auth_fields: string[];
  config_fields?: ConfigField[];
  capabilities: string[];
  rate_limit: string;
  docs_url: string;
};

export type ConnectorRecord = {
  id: string;
  service: string;
  serviceDisplayName?: string;
  status: string;
  auth_type?: string;
  sync_frequency: string;
  last_sync_at: string | null;
  error_message: string;
  created_at: string | null;
  contacts_count?: number;
  deals_count?: number;
  sync_count?: number;
};

export interface ConnectorsListResponse {
  connectors: ConnectorRecord[];
  tier: string;
  connector_limit: number;
  connectors_used: number;
}

export type ConnectorLog = {
  id: string;
  event_type: string;
  status: string;
  record_count: number;
  duration_ms: number | null;
  error_message: string;
  details: Record<string, unknown>;
  created_at: string;
};

export const connectorsApi = {
  available: async (): Promise<{ connectors: ConnectorDef[] }> => {
    const { data } = await api.get('/api/connectors/available');
    return data;
  },

  list: async (): Promise<ConnectorsListResponse> => {
    const { data } = await api.get('/api/connectors');
    return data;
  },

  update: async (
    connectorId: string,
    updates: Record<string, unknown>,
  ): Promise<{ success: boolean }> => {
    const { data } = await api.put(`/api/connectors/${connectorId}`, updates);
    return data;
  },

  create: async (
    service: string,
    config: Record<string, string>,
    sync_frequency: string = 'hourly',
  ): Promise<{ connector: ConnectorRecord }> => {
    const { data } = await api.post('/api/connectors', {
      service,
      config,
      sync_frequency,
    });
    return data;
  },

  remove: async (connectorId: string): Promise<{ success: boolean }> => {
    const { data } = await api.delete(`/api/connectors/${connectorId}`);
    return data;
  },

  status: async (connectorId: string): Promise<{
    connector_id: string;
    service: string;
    db_status: string;
    live_status: Record<string, unknown>;
  }> => {
    const { data } = await api.get(`/api/connectors/${connectorId}/status`);
    return data;
  },

  sync: async (connectorId: string): Promise<{
    success: boolean;
    status: string;
    record_count: number;
    duration_ms: number;
    last_sync_at: string;
  }> => {
    const { data } = await api.post(`/api/connectors/${connectorId}/sync`);
    return data;
  },

  logs: async (connectorId: string): Promise<{
    connector_id: string;
    logs: ConnectorLog[];
    total: number;
  }> => {
    const { data } = await api.get(`/api/connectors/${connectorId}/logs`);
    return data;
  },

  // -- OAuth 2.0 --

  oauthAuthorize: async (service: string, next?: string): Promise<void> => {
    // Navigate to the OAuth authorize endpoint (redirects to provider)
    const params = next ? `?next=${encodeURIComponent(next)}` : '';
    window.location.href = `/api/connectors/oauth/authorize/${service}${params}`;
  },

  // -- Spreadsheet picker (Google Sheets OAuth) --

  listSpreadsheets: async (): Promise<{
    success: boolean;
    spreadsheets: Array<{
      id: string;
      name: string;
      modifiedTime: string;
      webViewLink: string;
    }>;
    connectorId: string;
  }> => {
    const { data } = await api.get('/api/connectors/oauth/connected-sheets');
    return data;
  },

  selectSpreadsheet: async (spreadsheetId: string): Promise<{
    success: boolean;
    message: string;
    sync_result: Record<string, unknown>;
  }> => {
    const { data } = await api.post('/api/connectors/oauth/connected-sheets/select', {
      spreadsheet_id: spreadsheetId,
    });
    return data;
  },
};

// Re-export SMS/Call API
export * from './smsCall';