@hasna/connectors 0.7.2 → 0.8.0

package/connectors/connect-affinity/scripts/release.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+/**
+ * Release script for publishing to npm
+ *
+ * Usage:
+ *   bun run release        # Build, bump version, and publish
+ *   bun run release:dry    # Dry run (preview only)
+ *
+ * Features:
+ *   - Auto-fetches current npm version
+ *   - Bumps patch version if needed
+ *   - Creates git tag
+ *   - Publishes to npm
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+const isDryRun = process.argv.includes('--dry-run');
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+function exec(command: string, silent = false): string {
+  try {
+    const result = execSync(command, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : 'inherit',
+    });
+    return result?.trim() || '';
+  } catch (err) {
+    if (silent) {
+      return '';
+    }
+    throw err;
+  }
+}
+
+function log(message: string): void {
+  console.log(`\x1b[36m▸\x1b[0m ${message}`);
+}
+
+function success(message: string): void {
+  console.log(`\x1b[32m✓\x1b[0m ${message}`);
+}
+
+function warn(message: string): void {
+  console.log(`\x1b[33m⚠\x1b[0m ${message}`);
+}
+
+function error(message: string): void {
+  console.error(`\x1b[31m✗\x1b[0m ${message}`);
+}
+
+function parseVersion(version: string): { major: number; minor: number; patch: number } {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major, minor, patch };
+}
+
+function bumpPatch(version: string): string {
+  const { major, minor, patch } = parseVersion(version);
+  return `${major}.${minor}.${patch + 1}`;
+}
+
+async function main(): Promise<void> {
+  // Read package.json
+  const packageJsonPath = 'package.json';
+  const packageJson: PackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  const { name, version: localVersion } = packageJson;
+
+  log(`Package: ${name}`);
+  log(`Local version: ${localVersion}`);
+
+  // Get current npm version
+  let npmVersion = '';
+  try {
+    npmVersion = exec(`npm view ${name} version 2>/dev/null`, true);
+    log(`npm version: ${npmVersion || 'not published'}`);
+  } catch {
+    log('npm version: not published yet');
+  }
+
+  // Determine new version
+  let newVersion = localVersion;
+  if (npmVersion) {
+    const localParsed = parseVersion(localVersion);
+    const npmParsed = parseVersion(npmVersion);
+
+    // If local version <= npm version, bump from npm version
+    if (
+      localParsed.major < npmParsed.major ||
+      (localParsed.major === npmParsed.major && localParsed.minor < npmParsed.minor) ||
+      (localParsed.major === npmParsed.major &&
+        localParsed.minor === npmParsed.minor &&
+        localParsed.patch <= npmParsed.patch)
+    ) {
+      newVersion = bumpPatch(npmVersion);
+    }
+  }
+
+  if (newVersion !== localVersion) {
+    log(`Bumping version: ${localVersion} → ${newVersion}`);
+
+    if (!isDryRun) {
+      packageJson.version = newVersion;
+      writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+    }
+  } else {
+    log(`Version unchanged: ${newVersion}`);
+  }
+
+  // Run typecheck
+  log('Running typecheck...');
+  if (!isDryRun) {
+    exec('bun run typecheck');
+    success('Typecheck passed');
+  }
+
+  // Build
+  log('Building...');
+  if (!isDryRun) {
+    exec('bun run build');
+    success('Build completed');
+  }
+
+  // Git operations
+  const gitStatus = exec('git status --porcelain', true);
+  if (gitStatus) {
+    log('Staging changes...');
+    if (!isDryRun) {
+      exec('git add package.json');
+      exec(`git commit -m "chore: release v${newVersion}"`);
+    }
+  }
+
+  // Create git tag
+  const tagName = `v${newVersion}`;
+  log(`Creating tag: ${tagName}`);
+  if (!isDryRun) {
+    try {
+      exec(`git tag ${tagName}`);
+      success(`Tag ${tagName} created`);
+    } catch {
+      warn(`Tag ${tagName} already exists`);
+    }
+  }
+
+  // Publish
+  log('Publishing to npm...');
+  if (isDryRun) {
+    warn('Dry run - skipping publish');
+    exec('npm publish --dry-run');
+  } else {
+    exec('npm publish');
+    success(`Published ${name}@${newVersion}`);
+  }
+
+  // Push tags
+  if (!isDryRun) {
+    log('Pushing tags...');
+    try {
+      exec('git push --tags');
+      success('Tags pushed');
+    } catch {
+      warn('Failed to push tags (you may need to push manually)');
+    }
+  }
+
+  console.log('');
+  success(`Release ${isDryRun ? '(dry run) ' : ''}complete: ${name}@${newVersion}`);
+}
+
+main().catch((err) => {
+  error(String(err));
+  process.exit(1);
+});

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

@@ -0,0 +1,176 @@
+import type { ConnectorConfig } from '../types';
+import { ConnectorApiError, parseApiError } from '../types';
+
+const DEFAULT_BASE_URL = 'https://api.affinity.co';
+
+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>;
+  retries?: number;
+  timeout?: number;
+}
+
+export class ConnectorClient {
+  private readonly apiKey: string;
+  private readonly apiSecret?: string;
+  private readonly baseUrl: string;
+
+  constructor(config: ConnectorConfig) {
+    const key = config.apiKey || config.token || config.accessToken;
+    if (!key) {
+      throw new Error('API key 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();
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
+    return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
+  }
+
+  private isRetryableStatus(status: number): boolean {
+    return status === 429 || (status >= 500 && status < 600);
+  }
+
+  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': `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 {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        const response = await fetch(url, {
+          ...fetchOptions,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+        lastStatus = response.status;
+
+        if (response.status === 204) {
+          return {} as T;
+        }
+
+        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();
+        }
+
+        if (!response.ok) {
+          if (this.isRetryableStatus(response.status) && attempt < retries) {
+            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));
+
+        if (lastError.name === 'AbortError') {
+          lastError = new Error(`Request timeout after ${timeout}ms`);
+        }
+
+        if (attempt < retries && !(err instanceof ConnectorApiError)) {
+          await this.sleep(this.getRetryDelay(attempt));
+          continue;
+        }
+
+        throw err;
+      }
+    }
+
+    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 });
+  }
+
+  getApiKeyPreview(): string {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+}

package/connectors/connect-affinity/src/api/fields.ts

@@ -0,0 +1,18 @@
+import type { ConnectorClient } from './client';
+import type { FieldValue, FieldValueCreateParams } from '../types';
+
+export class FieldValuesApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async create(data: FieldValueCreateParams): Promise<FieldValue> {
+    return this.client.post<FieldValue>('/field-values', data);
+  }
+
+  async update(id: number, value: unknown): Promise<FieldValue> {
+    return this.client.put<FieldValue>(`/field-values/${id}`, { value });
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.client.delete(`/field-values/${id}`);
+  }
+}

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

@@ -0,0 +1,54 @@
+import type { ConnectorConfig } from '../types';
+import { ConnectorClient } from './client';
+import { PersonsApi } from './persons';
+import { OrganizationsApi } from './organizations';
+import { OpportunitiesApi } from './opportunities';
+import { ListsApi } from './lists';
+import { NotesApi } from './notes';
+import { FieldValuesApi } from './fields';
+
+export class Connector {
+  private readonly client: ConnectorClient;
+
+  public readonly persons: PersonsApi;
+  public readonly organizations: OrganizationsApi;
+  public readonly opportunities: OpportunitiesApi;
+  public readonly lists: ListsApi;
+  public readonly notes: NotesApi;
+  public readonly fieldValues: FieldValuesApi;
+
+  constructor(config: ConnectorConfig) {
+    this.client = new ConnectorClient(config);
+    this.persons = new PersonsApi(this.client);
+    this.organizations = new OrganizationsApi(this.client);
+    this.opportunities = new OpportunitiesApi(this.client);
+    this.lists = new ListsApi(this.client);
+    this.notes = new NotesApi(this.client);
+    this.fieldValues = new FieldValuesApi(this.client);
+  }
+
+  static fromEnv(): Connector {
+    const apiKey = process.env.AFFINITY_API_KEY;
+
+    if (!apiKey) {
+      throw new Error('AFFINITY_API_KEY environment variable is required');
+    }
+    return new Connector({ apiKey });
+  }
+
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  getClient(): ConnectorClient {
+    return this.client;
+  }
+}
+
+export { ConnectorClient } from './client';
+export { PersonsApi } from './persons';
+export { OrganizationsApi } from './organizations';
+export { OpportunitiesApi } from './opportunities';
+export { ListsApi } from './lists';
+export { NotesApi } from './notes';
+export { FieldValuesApi } from './fields';

package/connectors/connect-affinity/src/api/lists.ts

@@ -0,0 +1,34 @@
+import type { ConnectorClient } from './client';
+import type { AffinityList, ListEntry, ListEntryCreateParams, Field, ListParams, PaginatedResponse } from '../types';
+
+export class ListsApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async list(params?: ListParams): Promise<PaginatedResponse<AffinityList>> {
+    return this.client.get<PaginatedResponse<AffinityList>>('/v2/lists', params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async get(id: number): Promise<AffinityList> {
+    return this.client.get<AffinityList>(`/v2/lists/${id}`);
+  }
+
+  async getFields(listId: number): Promise<PaginatedResponse<Field>> {
+    return this.client.get<PaginatedResponse<Field>>(`/v2/lists/${listId}/fields`);
+  }
+
+  async listEntries(listId: number, params?: ListParams): Promise<PaginatedResponse<ListEntry>> {
+    return this.client.get<PaginatedResponse<ListEntry>>(`/v2/lists/${listId}/list-entries`, params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async getEntry(listId: number, entryId: number): Promise<ListEntry> {
+    return this.client.get<ListEntry>(`/v2/lists/${listId}/list-entries/${entryId}`);
+  }
+
+  async createEntry(listId: number, data: ListEntryCreateParams): Promise<ListEntry> {
+    return this.client.post<ListEntry>(`/v2/lists/${listId}/list-entries`, data);
+  }
+
+  async deleteEntry(listId: number, entryId: number): Promise<void> {
+    await this.client.delete(`/v2/lists/${listId}/list-entries/${entryId}`);
+  }
+}

package/connectors/connect-affinity/src/api/notes.ts

@@ -0,0 +1,26 @@
+import type { ConnectorClient } from './client';
+import type { Note, NoteCreateParams, ListParams, PaginatedResponse } from '../types';
+
+export class NotesApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async list(params?: ListParams & { person_id?: number; organization_id?: number; opportunity_id?: number }): Promise<PaginatedResponse<Note>> {
+    return this.client.get<PaginatedResponse<Note>>('/v2/notes', params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async get(id: number): Promise<Note> {
+    return this.client.get<Note>(`/v2/notes/${id}`);
+  }
+
+  async create(data: NoteCreateParams): Promise<Note> {
+    return this.client.post<Note>('/v2/notes', data);
+  }
+
+  async update(id: number, data: { content: string }): Promise<Note> {
+    return this.client.patch<Note>(`/v2/notes/${id}`, data);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.client.delete(`/v2/notes/${id}`);
+  }
+}

package/connectors/connect-affinity/src/api/opportunities.ts

@@ -0,0 +1,30 @@
+import type { ConnectorClient } from './client';
+import type { Opportunity, OpportunityCreateParams, ListParams, PaginatedResponse } from '../types';
+
+export class OpportunitiesApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async list(params?: ListParams): Promise<PaginatedResponse<Opportunity>> {
+    return this.client.get<PaginatedResponse<Opportunity>>('/v2/opportunities', params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async get(id: number, fieldIds?: number[]): Promise<Opportunity> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (fieldIds?.length) {
+      params.fieldIds = fieldIds.join(',');
+    }
+    return this.client.get<Opportunity>(`/v2/opportunities/${id}`, params);
+  }
+
+  async create(data: OpportunityCreateParams): Promise<Opportunity> {
+    return this.client.post<Opportunity>('/v2/opportunities', data);
+  }
+
+  async update(id: number, data: Partial<OpportunityCreateParams>): Promise<Opportunity> {
+    return this.client.patch<Opportunity>(`/v2/opportunities/${id}`, data);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.client.delete(`/v2/opportunities/${id}`);
+  }
+}

package/connectors/connect-affinity/src/api/organizations.ts

@@ -0,0 +1,30 @@
+import type { ConnectorClient } from './client';
+import type { Organization, OrganizationCreateParams, ListParams, PaginatedResponse } from '../types';
+
+export class OrganizationsApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async list(params?: ListParams): Promise<PaginatedResponse<Organization>> {
+    return this.client.get<PaginatedResponse<Organization>>('/v2/companies', params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async get(id: number, fieldIds?: number[]): Promise<Organization> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (fieldIds?.length) {
+      params.fieldIds = fieldIds.join(',');
+    }
+    return this.client.get<Organization>(`/v2/companies/${id}`, params);
+  }
+
+  async create(data: OrganizationCreateParams): Promise<Organization> {
+    return this.client.post<Organization>('/v2/companies', data);
+  }
+
+  async update(id: number, data: Partial<OrganizationCreateParams>): Promise<Organization> {
+    return this.client.patch<Organization>(`/v2/companies/${id}`, data);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.client.delete(`/v2/companies/${id}`);
+  }
+}

package/connectors/connect-affinity/src/api/persons.ts

@@ -0,0 +1,30 @@
+import type { ConnectorClient } from './client';
+import type { Person, PersonCreateParams, ListParams, PaginatedResponse } from '../types';
+
+export class PersonsApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  async list(params?: ListParams): Promise<PaginatedResponse<Person>> {
+    return this.client.get<PaginatedResponse<Person>>('/v2/persons', params as Record<string, string | number | boolean | undefined>);
+  }
+
+  async get(id: number, fieldIds?: number[]): Promise<Person> {
+    const params: Record<string, string | number | boolean | undefined> = {};
+    if (fieldIds?.length) {
+      params.fieldIds = fieldIds.join(',');
+    }
+    return this.client.get<Person>(`/v2/persons/${id}`, params);
+  }
+
+  async create(data: PersonCreateParams): Promise<Person> {
+    return this.client.post<Person>('/v2/persons', data);
+  }
+
+  async update(id: number, data: Partial<PersonCreateParams>): Promise<Person> {
+    return this.client.patch<Person>(`/v2/persons/${id}`, data);
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.client.delete(`/v2/persons/${id}`);
+  }
+}