@startsimpli/api 0.1.0 → 0.2.2

package/src/__tests__/entity-query-builder.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest';
+import { EntityQueryBuilder } from '../utils/entity-query-builder';
+
+describe('EntityQueryBuilder', () => {
+  it('builds empty params by default', () => {
+    const builder = new EntityQueryBuilder();
+    expect(builder.build()).toEqual({});
+    expect(builder.toQueryString()).toBe('');
+  });
+
+  describe('withTags', () => {
+    it('adds a single tag', () => {
+      const params = new EntityQueryBuilder()
+        .withTags('quality:tier_1')
+        .build();
+      expect(params.tags).toBe('quality:tier_1');
+    });
+
+    it('adds multiple tags at once', () => {
+      const params = new EntityQueryBuilder()
+        .withTags('quality:tier_1', 'status:prospect')
+        .build();
+      expect(params.tags).toBe('quality:tier_1,status:prospect');
+    });
+
+    it('accumulates tags across multiple calls', () => {
+      const params = new EntityQueryBuilder()
+        .withTags('quality:tier_1')
+        .withTags('status:prospect')
+        .build();
+      expect(params.tags).toBe('quality:tier_1,status:prospect');
+    });
+
+    it('does nothing for empty args', () => {
+      const params = new EntityQueryBuilder().withTags().build();
+      expect(params.tags).toBeUndefined();
+    });
+  });
+
+  describe('withMetrics', () => {
+    it('adds metric filters', () => {
+      const params = new EntityQueryBuilder()
+        .withMetrics('financial:aum__gte:100000000')
+        .build();
+      expect(params.metrics).toBe('financial:aum__gte:100000000');
+    });
+
+    it('accumulates metrics', () => {
+      const params = new EntityQueryBuilder()
+        .withMetrics('financial:aum__gte:100000000')
+        .withMetrics('check_size:min__gte:1000000')
+        .build();
+      expect(params.metrics).toBe(
+        'financial:aum__gte:100000000,check_size:min__gte:1000000'
+      );
+    });
+  });
+
+  describe('withProfiles', () => {
+    it('adds profile filters', () => {
+      const params = new EntityQueryBuilder()
+        .withProfiles('professional:linkedin')
+        .build();
+      expect(params.profiles).toBe('professional:linkedin');
+    });
+  });
+
+  describe('withAttributes', () => {
+    it('adds attribute filters', () => {
+      const params = new EntityQueryBuilder()
+        .withAttributes('demographic:location:san_francisco')
+        .build();
+      expect(params.attributes).toBe('demographic:location:san_francisco');
+    });
+  });
+
+  describe('paginate', () => {
+    it('sets page and page_size', () => {
+      const params = new EntityQueryBuilder()
+        .paginate(2, 50)
+        .build();
+      expect(params.page).toBe('2');
+      expect(params.page_size).toBe('50');
+    });
+  });
+
+  describe('search', () => {
+    it('sets search param', () => {
+      const params = new EntityQueryBuilder()
+        .search('acme corp')
+        .build();
+      expect(params.search).toBe('acme corp');
+    });
+
+    it('trims whitespace', () => {
+      const params = new EntityQueryBuilder()
+        .search('  acme  ')
+        .build();
+      expect(params.search).toBe('acme');
+    });
+
+    it('ignores empty search', () => {
+      const params = new EntityQueryBuilder()
+        .search('   ')
+        .build();
+      expect(params.search).toBeUndefined();
+    });
+  });
+
+  describe('sort', () => {
+    it('defaults to ascending', () => {
+      const params = new EntityQueryBuilder()
+        .sort('name')
+        .build();
+      expect(params.ordering).toBe('name');
+    });
+
+    it('supports descending', () => {
+      const params = new EntityQueryBuilder()
+        .sort('created_at', 'desc')
+        .build();
+      expect(params.ordering).toBe('-created_at');
+    });
+  });
+
+  describe('withDateRange', () => {
+    it('sets from and to dates', () => {
+      const params = new EntityQueryBuilder()
+        .withDateRange('created', new Date('2024-01-01'), new Date('2024-12-31'))
+        .build();
+      expect(params.created_after).toBe('2024-01-01');
+      expect(params.created_before).toBe('2024-12-31');
+    });
+
+    it('handles only from date', () => {
+      const params = new EntityQueryBuilder()
+        .withDateRange('created', new Date('2024-06-01'))
+        .build();
+      expect(params.created_after).toBe('2024-06-01');
+      expect(params.created_before).toBeUndefined();
+    });
+
+    it('handles only to date', () => {
+      const params = new EntityQueryBuilder()
+        .withDateRange('created', undefined, new Date('2024-12-31'))
+        .build();
+      expect(params.created_after).toBeUndefined();
+      expect(params.created_before).toBe('2024-12-31');
+    });
+  });
+
+  describe('toQueryString', () => {
+    it('returns ?-prefixed query string', () => {
+      const qs = new EntityQueryBuilder()
+        .paginate(1, 25)
+        .search('test')
+        .toQueryString();
+      expect(qs).toMatch(/^\?/);
+      expect(qs).toContain('page=1');
+      expect(qs).toContain('page_size=25');
+      expect(qs).toContain('search=test');
+    });
+  });
+
+  describe('chaining', () => {
+    it('supports full complex query', () => {
+      const params = new EntityQueryBuilder()
+        .entityType('ORGANIZATION')
+        .withTags('quality:tier_1', 'status:prospect')
+        .withMetrics('financial:aum__gte:100000000')
+        .withProfiles('professional:linkedin')
+        .paginate(1, 25)
+        .search('venture')
+        .sort('name', 'asc')
+        .build();
+
+      expect(params.entity_type).toBe('ORGANIZATION');
+      expect(params.tags).toBe('quality:tier_1,status:prospect');
+      expect(params.metrics).toBe('financial:aum__gte:100000000');
+      expect(params.profiles).toBe('professional:linkedin');
+      expect(params.page).toBe('1');
+      expect(params.page_size).toBe('25');
+      expect(params.search).toBe('venture');
+      expect(params.ordering).toBe('name');
+    });
+  });
+
+  describe('clear', () => {
+    it('resets all parameters', () => {
+      const builder = new EntityQueryBuilder()
+        .withTags('quality:tier_1')
+        .paginate(1, 25);
+      builder.clear();
+      expect(builder.build()).toEqual({});
+    });
+  });
+});

package/src/__tests__/funnels-api.test.ts

@@ -0,0 +1,237 @@
+/**
+ * FunnelsApi unit tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { FunnelsApi, isFunnelRunConflict, isFunnelValidationError } from '../lib/funnels-api';
+import { ApiException } from '../lib/error-handler';
+import type { ApiClient } from '../lib/api-client';
+
+function makeClient(overrides: Partial<ApiClient> = {}): ApiClient {
+  return {
+    get: vi.fn(),
+    post: vi.fn(),
+    patch: vi.fn(),
+    delete: vi.fn(),
+    baseUrl: 'http://localhost:8000',
+    fetch: {} as any,
+    setTokenGetter: vi.fn(),
+    setUnauthorizedHandler: vi.fn(),
+    ...overrides,
+  } as unknown as ApiClient;
+}
+
+const mockFunnel = {
+  id: 'funnel-1',
+  name: 'Test Funnel',
+  description: 'A test funnel',
+  status: 'active' as const,
+  entityType: 'contact' as const,
+  tags: ['product:market-simpli'],
+  stages: [],
+  stageCount: 0,
+  totalRuns: 0,
+  lastRunAt: null,
+  createdBy: 'user-1',
+  createdByName: 'Test User',
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const mockRun = {
+  id: 'run-1',
+  funnel: 'funnel-1',
+  status: 'completed' as const,
+  totalEntities: 100,
+  processedEntities: 100,
+  resultsByStage: { 'stage-1': 50 },
+  startedAt: '2024-01-01T00:00:00Z',
+  completedAt: '2024-01-01T00:01:00Z',
+  errorMessage: null,
+  createdBy: 'user-1',
+  createdAt: '2024-01-01T00:00:00Z',
+};
+
+const mockPaginated = <T>(results: T[]) => ({
+  count: results.length,
+  next: null,
+  previous: null,
+  results,
+});
+
+describe('FunnelsApi', () => {
+  let client: ApiClient;
+  let api: FunnelsApi;
+
+  beforeEach(() => {
+    client = makeClient();
+    api = new FunnelsApi(client);
+  });
+
+  describe('list', () => {
+    it('calls GET funnels with no params when no filters given', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([mockFunnel]));
+      await api.list();
+      expect(client.get).toHaveBeenCalledWith('funnels');
+    });
+
+    it('passes status filter as query param', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([mockFunnel]));
+      await api.list({ status: 'active' });
+      expect(client.get).toHaveBeenCalledWith(expect.stringContaining('status=active'));
+    });
+
+    it('passes multiple tags as repeated query params', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([mockFunnel]));
+      await api.list({ tags: ['campaign:abc', 'product:market-simpli'] });
+      const endpoint = vi.mocked(client.get).mock.calls[0][0] as string;
+      expect(endpoint).toContain('tags=campaign%3Aabc');
+      expect(endpoint).toContain('tags=product%3Amarket-simpli');
+    });
+
+    it('passes pagination params', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([]));
+      await api.list({ page: 2, pageSize: 25 });
+      const endpoint = vi.mocked(client.get).mock.calls[0][0] as string;
+      expect(endpoint).toContain('page=2');
+      expect(endpoint).toContain('pageSize=25');
+    });
+  });
+
+  describe('get', () => {
+    it('calls GET funnels/:id', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockFunnel);
+      const result = await api.get('funnel-1');
+      expect(client.get).toHaveBeenCalledWith('funnels/funnel-1');
+      expect(result).toEqual(mockFunnel);
+    });
+  });
+
+  describe('create', () => {
+    it('calls POST funnels with data', async () => {
+      vi.mocked(client.post).mockResolvedValue(mockFunnel);
+      const input = { name: 'New Funnel', entityType: 'contact' as const, tags: ['campaign:abc'] };
+      await api.create(input);
+      expect(client.post).toHaveBeenCalledWith('funnels', input);
+    });
+  });
+
+  describe('update', () => {
+    it('calls PATCH funnels/:id with data', async () => {
+      vi.mocked(client.patch).mockResolvedValue(mockFunnel);
+      await api.update('funnel-1', { name: 'Renamed' });
+      expect(client.patch).toHaveBeenCalledWith('funnels/funnel-1', { name: 'Renamed' });
+    });
+  });
+
+  describe('delete', () => {
+    it('calls DELETE funnels/:id', async () => {
+      vi.mocked(client.delete).mockResolvedValue(undefined);
+      await api.delete('funnel-1');
+      expect(client.delete).toHaveBeenCalledWith('funnels/funnel-1');
+    });
+  });
+
+  describe('run', () => {
+    it('calls POST funnels/:id/run with empty body by default', async () => {
+      vi.mocked(client.post).mockResolvedValue(mockRun);
+      await api.run('funnel-1');
+      expect(client.post).toHaveBeenCalledWith('funnels/funnel-1/run', {});
+    });
+
+    it('passes entityIds in body when provided', async () => {
+      vi.mocked(client.post).mockResolvedValue(mockRun);
+      await api.run('funnel-1', { entityIds: ['e1', 'e2'] });
+      expect(client.post).toHaveBeenCalledWith('funnels/funnel-1/run', { entityIds: ['e1', 'e2'] });
+    });
+  });
+
+  describe('getRuns', () => {
+    it('calls GET funnels/:id/runs', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([mockRun]));
+      await api.getRuns('funnel-1');
+      expect(client.get).toHaveBeenCalledWith('funnels/funnel-1/runs');
+    });
+
+    it('passes page and pageSize filters', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([]));
+      await api.getRuns('funnel-1', { page: 2, pageSize: 10 });
+      const endpoint = vi.mocked(client.get).mock.calls[0][0] as string;
+      expect(endpoint).toContain('page=2');
+      expect(endpoint).toContain('pageSize=10');
+    });
+  });
+
+  describe('getRun', () => {
+    it('calls GET funnel-runs/:runId (global endpoint, funnelId ignored)', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockRun);
+      await api.getRun('funnel-1', 'run-1');
+      expect(client.get).toHaveBeenCalledWith('funnel-runs/run-1');
+    });
+  });
+
+  describe('preview', () => {
+    it('throws Not implemented (endpoint missing in Django)', async () => {
+      // BEAD: fund-your-startup-rgi4 - funnels/{id}/preview does not exist in Django
+      await expect(api.preview('funnel-1', [])).rejects.toThrow('Not implemented');
+    });
+  });
+
+  describe('cancelRun', () => {
+    it('calls POST funnel-runs/:runId/cancel', async () => {
+      vi.mocked(client.post).mockResolvedValue(mockRun);
+      await api.cancelRun('run-1');
+      expect(client.post).toHaveBeenCalledWith('funnel-runs/run-1/cancel', {});
+    });
+  });
+
+  describe('listRunsGlobal', () => {
+    it('calls GET funnel-runs with no params when no filters given', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([mockRun]));
+      await api.listRunsGlobal();
+      expect(client.get).toHaveBeenCalledWith('funnel-runs');
+    });
+
+    it('passes funnel filter as query param', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([]));
+      await api.listRunsGlobal({ funnel: 'funnel-1' });
+      expect(client.get).toHaveBeenCalledWith(expect.stringContaining('funnel=funnel-1'));
+    });
+  });
+
+  describe('listTemplates', () => {
+    it('calls GET funnels/templates', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([]));
+      await api.listTemplates();
+      expect(client.get).toHaveBeenCalledWith('funnels/templates');
+    });
+
+    it('passes category filter', async () => {
+      vi.mocked(client.get).mockResolvedValue(mockPaginated([]));
+      await api.listTemplates({ category: 'vc' });
+      expect(client.get).toHaveBeenCalledWith(expect.stringContaining('category=vc'));
+    });
+  });
+});
+
+describe('error helpers', () => {
+  it('isFunnelRunConflict returns true for 409 ApiException', () => {
+    const err = new ApiException('Funnel already running', { status: 409 });
+    expect(isFunnelRunConflict(err)).toBe(true);
+  });
+
+  it('isFunnelRunConflict returns false for non-409 errors', () => {
+    expect(isFunnelRunConflict(new ApiException('Not found', { status: 404 }))).toBe(false);
+    expect(isFunnelRunConflict(new Error('something'))).toBe(false);
+  });
+
+  it('isFunnelValidationError returns true for 400 with errors', () => {
+    const err = new ApiException('Validation failed', { status: 400, errors: { entityType: ['Required'] } });
+    expect(isFunnelValidationError(err)).toBe(true);
+  });
+
+  it('isFunnelValidationError returns false for 400 without errors field', () => {
+    const err = new ApiException('Bad request', { status: 400 });
+    expect(isFunnelValidationError(err)).toBe(false);
+  });
+});

package/src/__tests__/jwt-refresh.test.ts

@@ -98,24 +98,21 @@ describe('JWT Refresh Flow', () => {
       onTokenRefresh: refreshCallback,
     });
 
-    // Both calls return 401
-    mockFetch.mockResolvedValue({
-      status: 401,
-      ok: false,
-    });
+    const mock401 = { status: 401, ok: false, headers: new Headers(), text: async () => '' };
+    const mock200 = { status: 200, ok: true, json: async () => ({ data: 'success' }) };
 
-    // Refresh returns new token (with delay)
+    // Both initial requests return 401, then both retries succeed
+    mockFetch
+      .mockResolvedValueOnce(mock401)  // request 1 initial
+      .mockResolvedValueOnce(mock401)  // request 2 initial
+      .mockResolvedValueOnce(mock200)  // request 1 retry
+      .mockResolvedValueOnce(mock200); // request 2 retry
+
+    // Refresh returns new token (with delay to allow both 401s to queue)
     refreshCallback.mockImplementation(
-      () => new Promise((resolve) => setTimeout(() => resolve('new-token'), 100))
+      () => new Promise((resolve) => setTimeout(() => resolve('new-token'), 50))
     );
 
-    // Retry succeeds
-    mockFetch.mockResolvedValueOnce({
-      status: 200,
-      ok: true,
-      json: async () => ({ data: 'success' }),
-    });
-
     // Make 2 concurrent requests
     const promise1 = wrapper.get('/api/v1/messages/');
     const promise2 = wrapper.get('/api/v1/contacts/');

package/src/__tests__/url-builder.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { buildUrl, buildQueryString, normalizeId } from '../utils/url-builder';
+import { buildUrl, buildQueryString, normalizeId, resolveApiUrl } from '../utils/url-builder';
 
 describe('buildUrl', () => {
   it('should build URL with base and endpoint', () => {
@@ -105,6 +105,32 @@ describe('buildQueryString', () => {
   });
 });
 
+describe('resolveApiUrl', () => {
+  it('passes through absolute input URLs unchanged', () => {
+    expect(resolveApiUrl('https://api.example.com/v1/contacts/')).toBe('https://api.example.com/v1/contacts/');
+    expect(resolveApiUrl('https://api.example.com/v1/contacts/', 'http://localhost:8000')).toBe('https://api.example.com/v1/contacts/');
+  });
+
+  it('returns path as-is when baseUrl is empty', () => {
+    expect(resolveApiUrl('/api/v1/contacts/')).toBe('/api/v1/contacts/');
+    expect(resolveApiUrl('/api/v1/contacts/', '')).toBe('/api/v1/contacts/');
+  });
+
+  it('normalizes paths without leading slash', () => {
+    expect(resolveApiUrl('api/v1/contacts/')).toBe('/api/v1/contacts/');
+  });
+
+  it('joins with absolute baseUrl via URL constructor', () => {
+    expect(resolveApiUrl('/api/v1/contacts/', 'http://localhost:8000')).toBe('http://localhost:8000/api/v1/contacts/');
+    expect(resolveApiUrl('/api/v1/contacts/', 'https://api.example.com')).toBe('https://api.example.com/api/v1/contacts/');
+  });
+
+  it('joins with relative baseUrl', () => {
+    expect(resolveApiUrl('/api/v1/contacts/', '/proxy')).toBe('/proxy/api/v1/contacts/');
+    expect(resolveApiUrl('/api/v1/contacts/', '/proxy/')).toBe('/proxy/api/v1/contacts/');
+  });
+});
+
 describe('normalizeId', () => {
   it('should return number ID as-is', () => {
     expect(normalizeId(123)).toBe(123);

package/src/__tests__/validate-response.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { z } from 'zod';
+import { validateApiResponse } from '../utils/validate-response';
+
+describe('validateApiResponse', () => {
+  const schema = z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+  });
+
+  it('returns parsed data when schema matches', () => {
+    const data = { id: '1', name: 'Alice', email: 'alice@example.com' };
+    const result = validateApiResponse(data, schema);
+    expect(result).toEqual(data);
+  });
+
+  it('returns raw data on mismatch (does not throw)', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const data = { id: '1', name: 'Alice', email: 'not-an-email', extra: true };
+    const result = validateApiResponse(data, schema);
+
+    // Returns data as-is (cast, not validated)
+    expect(result).toBe(data);
+    expect((result as any).extra).toBe(true);
+
+    // Warning was logged
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0][0]).toContain('Schema mismatch');
+
+    warnSpy.mockRestore();
+  });
+
+  it('includes context label in warning', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    validateApiResponse({ id: 123 }, schema, 'contacts.list');
+
+    expect(warnSpy.mock.calls[0][0]).toContain('[contacts.list]');
+
+    warnSpy.mockRestore();
+  });
+
+  it('strips extra fields when schema matches', () => {
+    const strictSchema = z.object({ id: z.string() }).strict();
+    const data = { id: '1', extra: 'field' };
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const result = validateApiResponse(data, strictSchema);
+
+    // strict schema will fail — returns raw data
+    expect(result).toBe(data);
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+
+  it('handles completely wrong data shape', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const result = validateApiResponse('just a string', schema);
+    expect(result).toBe('just a string');
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+});

package/src/constants/endpoints.ts

@@ -36,4 +36,17 @@ export const ENDPOINTS = {
   MESSAGES: 'messages',
   MESSAGE: (id: string) => `messages/${id}`,
   MESSAGE_SEND: (id: string) => `messages/${id}/send`,
+
+  // Funnels
+  FUNNELS: 'funnels',
+  FUNNEL: (id: string) => `funnels/${id}`,
+  FUNNEL_RUN: (id: string) => `funnels/${id}/run`,
+  FUNNEL_RUNS: (id: string) => `funnels/${id}/runs`,
+  FUNNEL_RUN_ITEM: (funnelId: string, runId: string) => `funnels/${funnelId}/runs/${runId}`,
+  FUNNEL_PREVIEW: (id: string) => `funnels/${id}/preview`,
+  FUNNEL_RESULTS: (id: string) => `funnels/${id}/results`,
+  FUNNEL_TEMPLATES: 'funnels/templates',
+  FUNNEL_RUN_BY_ID: (runId: string) => `funnel-runs/${runId}`,
+  FUNNEL_RUN_CANCEL: (runId: string) => `funnel-runs/${runId}/cancel`,
+  FUNNEL_RUNS_GLOBAL: 'funnel-runs',
 } as const;

package/src/constants/options.ts

@@ -0,0 +1,83 @@
+/**
+ * Shared CRM option constants for dropdown fields.
+ *
+ * Used across market-simpli and raise-simpli for company/contact field dropdowns.
+ */
+
+export interface SelectOption<T extends string = string> {
+  value: T
+  label: string
+}
+
+export const COMPANY_SIZE_OPTIONS = [
+  { value: 'startup', label: 'Startup (1-10)' },
+  { value: 'small', label: 'Small (11-50)' },
+  { value: 'smb', label: 'SMB (51-200)' },
+  { value: 'mid_market', label: 'Mid-Market (201-1000)' },
+  { value: 'enterprise', label: 'Enterprise (1000+)' },
+] as const satisfies SelectOption[]
+
+export const LIFECYCLE_STAGE_OPTIONS = [
+  { value: 'subscriber', label: 'Subscriber' },
+  { value: 'lead', label: 'Lead' },
+  { value: 'mql', label: 'MQL' },
+  { value: 'sql', label: 'SQL' },
+  { value: 'opportunity', label: 'Opportunity' },
+  { value: 'customer', label: 'Customer' },
+  { value: 'evangelist', label: 'Evangelist' },
+] as const satisfies SelectOption[]
+
+export const REVENUE_RANGE_OPTIONS = [
+  { value: 'pre_revenue', label: 'Pre-revenue' },
+  { value: '0_1m', label: '$0-$1M' },
+  { value: '1m_10m', label: '$1M-$10M' },
+  { value: '10m_50m', label: '$10M-$50M' },
+  { value: '50m_plus', label: '$50M+' },
+] as const satisfies SelectOption[]
+
+export const ACTIVITY_TYPE_OPTIONS = [
+  { value: 'call', label: 'Call' },
+  { value: 'email', label: 'Email' },
+  { value: 'meeting', label: 'Meeting' },
+  { value: 'demo', label: 'Demo' },
+  { value: 'note', label: 'Note' },
+  { value: 'task', label: 'Task' },
+] as const satisfies SelectOption[]
+
+export const ACTIVITY_OUTCOME_OPTIONS = [
+  { value: 'scheduled_demo', label: 'Scheduled Demo' },
+  { value: 'scheduled_meeting', label: 'Scheduled Meeting' },
+  { value: 'callback_later', label: 'Callback Later' },
+  { value: 'left_voicemail', label: 'Left Voicemail' },
+  { value: 'no_answer', label: 'No Answer' },
+  { value: 'not_interested', label: 'Not Interested' },
+  { value: 'successful', label: 'Successful' },
+  { value: 'unsuccessful', label: 'Unsuccessful' },
+] as const satisfies SelectOption[]
+
+export const LOSS_REASON_OPTIONS = [
+  { value: 'price', label: 'Price / Budget' },
+  { value: 'timing', label: 'Bad Timing' },
+  { value: 'competitor', label: 'Chose Competitor' },
+  { value: 'no_need', label: 'No Need' },
+  { value: 'no_response', label: 'No Response' },
+  { value: 'other', label: 'Other' },
+] as const satisfies SelectOption[]
+
+export const DEAL_STAGE_OPTIONS = [
+  { value: 'qualification', label: 'Qualification' },
+  { value: 'discovery', label: 'Discovery' },
+  { value: 'demo', label: 'Demo' },
+  { value: 'proposal', label: 'Proposal' },
+  { value: 'negotiation', label: 'Negotiation' },
+  { value: 'closed_won', label: 'Closed Won' },
+  { value: 'closed_lost', label: 'Closed Lost' },
+] as const satisfies SelectOption[]
+
+export type CompanySize = (typeof COMPANY_SIZE_OPTIONS)[number]['value']
+export type LifecycleStage = (typeof LIFECYCLE_STAGE_OPTIONS)[number]['value']
+export type RevenueRange = (typeof REVENUE_RANGE_OPTIONS)[number]['value']
+export type ActivityType = (typeof ACTIVITY_TYPE_OPTIONS)[number]['value']
+export type ActivityOutcome = (typeof ACTIVITY_OUTCOME_OPTIONS)[number]['value']
+export type LossReason = (typeof LOSS_REASON_OPTIONS)[number]['value']
+export type DealStage = (typeof DEAL_STAGE_OPTIONS)[number]['value']

package/src/hooks/index.ts

@@ -0,0 +1,4 @@
+export { useServerList } from './use-server-list'
+export type { ServerListOptions, ServerListResult } from './use-server-list'
+export { useServerDetail } from './use-server-detail'
+export type { ServerDetailResult } from './use-server-detail'