@elevasis/core 0.1.0

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/list-records/index.test.ts

@@ -0,0 +1,338 @@
+/**
+ * Tests for Attio listRecords fetch implementation
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { listRecords } from './index.js'
+import { ToolingError } from '../../../../../../types.js'
+
+// Mock fetch globally
+const mockFetch = vi.fn()
+global.fetch = mockFetch as typeof fetch
+
+describe('listRecords', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should list records successfully with default pagination', async () => {
+    const mockResponse = {
+      data: [
+        {
+          id: {
+            workspace_id: 'workspace-123',
+            object_id: 'object-456',
+            record_id: 'record-1'
+          },
+          created_at: '2024-01-01T12:00:00Z',
+          web_url: 'https://app.attio.com/workspace/record-1',
+          values: {
+            name: [{ first_name: 'John', last_name: 'Doe' }]
+          }
+        },
+        {
+          id: {
+            workspace_id: 'workspace-123',
+            object_id: 'object-456',
+            record_id: 'record-2'
+          },
+          created_at: '2024-01-02T12:00:00Z',
+          web_url: 'https://app.attio.com/workspace/record-2',
+          values: {
+            name: [{ first_name: 'Jane', last_name: 'Smith' }]
+          }
+        }
+      ]
+    }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    const result = await listRecords(
+      { apiKey: 'test-key' },
+      { object: 'people' }
+    )
+
+    expect(result.records).toHaveLength(2)
+    expect(result.records[0].id).toBe('record-1')
+    expect(result.records[1].id).toBe('record-2')
+    expect(result.hasMore).toBe(false) // Only 2 records, default limit is 500
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.attio.com/v2/objects/people/records/query',
+      expect.objectContaining({
+        method: 'POST',
+        headers: {
+          'Authorization': 'Bearer test-key',
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        },
+        body: JSON.stringify({
+          limit: 500,
+          offset: 0
+        })
+      })
+    )
+  })
+
+  it('should support custom limit and offset', async () => {
+    const mockResponse = {
+      data: Array.from({ length: 50 }, (_, i) => ({
+        id: {
+          workspace_id: 'workspace-123',
+          object_id: 'object-456',
+          record_id: `record-${i + 50}`
+        },
+        created_at: '2024-01-01T12:00:00Z',
+        web_url: `https://app.attio.com/workspace/record-${i + 50}`,
+        values: {}
+      }))
+    }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    const result = await listRecords(
+      { apiKey: 'test-key' },
+      { object: 'people', limit: 50, offset: 50 }
+    )
+
+    expect(result.records).toHaveLength(50)
+    expect(result.hasMore).toBe(true) // Returned count equals limit
+
+    const fetchCall = mockFetch.mock.calls[0][1] as { body: string }
+    const calledBody = JSON.parse(fetchCall.body)
+    expect(calledBody.limit).toBe(50)
+    expect(calledBody.offset).toBe(50)
+  })
+
+  it('should support filter parameters', async () => {
+    const mockResponse = { data: [] }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    await listRecords(
+      { apiKey: 'test-key' },
+      {
+        object: 'people',
+        filter: {
+          name: {
+            first_name: {
+              $eq: 'John'
+            }
+          }
+        }
+      }
+    )
+
+    const fetchCall = mockFetch.mock.calls[0][1] as { body: string }
+    const calledBody = JSON.parse(fetchCall.body)
+    expect(calledBody.filter).toEqual({
+      name: {
+        first_name: {
+          $eq: 'John'
+        }
+      }
+    })
+  })
+
+  it('should support sorts parameters', async () => {
+    const mockResponse = { data: [] }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    await listRecords(
+      { apiKey: 'test-key' },
+      {
+        object: 'people',
+        sorts: [
+          {
+            attribute: 'name',
+            field: 'last_name',
+            direction: 'asc'
+          }
+        ]
+      }
+    )
+
+    const fetchCall = mockFetch.mock.calls[0][1] as { body: string }
+    const calledBody = JSON.parse(fetchCall.body)
+    expect(calledBody.sorts).toEqual([
+      {
+        attribute: 'name',
+        field: 'last_name',
+        direction: 'asc'
+      }
+    ])
+  })
+
+  it('should support complex filters with logical operators', async () => {
+    const mockResponse = { data: [] }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    await listRecords(
+      { apiKey: 'test-key' },
+      {
+        object: 'deals',
+        filter: {
+          $and: [
+            {
+              value: {
+                value: {
+                  $gte: 10000
+                }
+              }
+            },
+            {
+              status: {
+                $eq: 'open'
+              }
+            }
+          ]
+        }
+      }
+    )
+
+    const fetchCall = mockFetch.mock.calls[0][1] as { body: string }
+    const calledBody = JSON.parse(fetchCall.body)
+    expect(calledBody.filter.$and).toHaveLength(2)
+  })
+
+  it('should throw credentials_invalid when API key is missing', async () => {
+    await expect(
+      listRecords(
+        { apiKey: '' },
+        { object: 'people' }
+      )
+    ).rejects.toThrow('Missing Attio API key')
+  })
+
+  it('should throw validation_error when object is missing', async () => {
+    await expect(
+      listRecords(
+        { apiKey: 'test-key' },
+        { object: '' }
+      )
+    ).rejects.toThrow('Missing required parameter: object')
+  })
+
+  it('should handle 401 authentication errors', async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 401,
+      statusText: 'Unauthorized',
+      text: async () => JSON.stringify({
+        status_code: 401,
+        type: 'authentication_error',
+        code: 'unauthorized',
+        message: 'Invalid API key'
+      })
+    })
+
+    try {
+      await listRecords(
+        { apiKey: 'invalid-key' },
+        { object: 'people' }
+      )
+    } catch (error) {
+      expect((error as ToolingError).errorType).toBe('credentials_invalid')
+    }
+  })
+
+  it('should work with different object types', async () => {
+    const mockResponse = {
+      data: [
+        {
+          id: {
+            workspace_id: 'workspace-123',
+            object_id: 'object-456',
+            record_id: 'company-1'
+          },
+          created_at: '2024-01-01T12:00:00Z',
+          web_url: 'https://app.attio.com/workspace/company-1',
+          values: {
+            name: 'Acme Corp'
+          }
+        }
+      ]
+    }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    const result = await listRecords(
+      { apiKey: 'test-key' },
+      { object: 'companies' }
+    )
+
+    expect(result.records).toHaveLength(1)
+    expect(result.records[0].values.name).toBe('Acme Corp')
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.attio.com/v2/objects/companies/records/query',
+      expect.anything()
+    )
+  })
+
+  it('should determine hasMore correctly based on limit', async () => {
+    // Case 1: Returned count < limit -> hasMore = false
+    const mockResponse1 = {
+      data: Array.from({ length: 25 }, (_, i) => ({
+        id: { workspace_id: 'w', object_id: 'o', record_id: `r-${i}` },
+        created_at: '2024-01-01T12:00:00Z',
+        web_url: `https://app.attio.com/w/r-${i}`,
+        values: {}
+      }))
+    }
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockResponse1
+    })
+
+    const result1 = await listRecords(
+      { apiKey: 'test-key' },
+      { object: 'people', limit: 50 }
+    )
+
+    expect(result1.hasMore).toBe(false)
+
+    // Case 2: Returned count = limit -> hasMore = true
+    const mockResponse2 = {
+      data: Array.from({ length: 50 }, (_, i) => ({
+        id: { workspace_id: 'w', object_id: 'o', record_id: `r-${i}` },
+        created_at: '2024-01-01T12:00:00Z',
+        web_url: `https://app.attio.com/w/r-${i}`,
+        values: {}
+      }))
+    }
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockResponse2
+    })
+
+    const result2 = await listRecords(
+      { apiKey: 'test-key' },
+      { object: 'people', limit: 50 }
+    )
+
+    expect(result2.hasMore).toBe(true)
+  })
+})

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/list-records/index.ts

@@ -0,0 +1,156 @@
+/**
+ * Attio List Records - Native Fetch Implementation
+ *
+ * Queries/lists records from an Attio object using native Node.js fetch API.
+ * Supports filtering, sorting, and pagination for all object types.
+ *
+ * API Endpoint: POST /v2/objects/{object}/records/query
+ * Documentation: https://developers.attio.com/reference/list-records
+ *
+ * Note: This is a POST endpoint (not GET) to support complex filter and sort criteria.
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type { AttioCredentials, QueryRecordsParams, QueryRecordsResult, AttioQueryResponse } from '../utils/types'
+
+/**
+ * Query/list records from an Attio object
+ *
+ * Uses native Node.js fetch API with retry logic for resilience.
+ * Supports advanced filtering, sorting, and offset-based pagination.
+ *
+ * Filter operators supported:
+ * - $eq, $ne (equality)
+ * - $gt, $gte, $lt, $lte (comparisons)
+ * - $contains, $starts_with (string matching)
+ * - $and, $or (logical operators)
+ *
+ * @param credentials - Attio API credentials (Bearer token)
+ * @param params - Object type, filter, sorts, limit, offset
+ * @param context - Execution context for logging
+ * @returns List of records with pagination info
+ * @throws ToolingError on API errors
+ */
+export async function listRecords(
+  credentials: AttioCredentials,
+  params: QueryRecordsParams,
+  context?: ExecutionContext
+): Promise<QueryRecordsResult> {
+  const { object, filter, sorts, limit = 500, offset = 0 } = params
+  const { apiKey } = credentials
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'listRecords'
+    })
+  }
+
+  // Validate parameters
+  if (!object) {
+    throw new ToolingError('validation_error', 'Missing required parameter: object', {
+      integration: 'attio',
+      method: 'listRecords',
+      params: { object }
+    })
+  }
+
+  // Build API URL
+  const url = `https://api.attio.com/v2/objects/${object}/records/query`
+
+  // Build request body
+  const requestBody: {
+    filter?: typeof filter
+    sorts?: typeof sorts
+    limit: number
+    offset: number
+  } = {
+    limit,
+    offset
+  }
+
+  // Only include filter and sorts if provided
+  if (filter) {
+    requestBody.filter = filter
+  }
+
+  if (sorts && sorts.length > 0) {
+    requestBody.sorts = sorts
+  }
+
+  try {
+    // Execute with retry logic
+    const data = await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      })
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'listRecords',
+          organizationId: context?.organizationId
+        })
+      }
+
+      // Parse response
+      const responseData = (await response.json()) as AttioQueryResponse
+
+      // Validate response structure
+      if (!responseData.data || !Array.isArray(responseData.data)) {
+        throw new ToolingError('api_error', 'Invalid response format: expected data array', {
+          integration: 'attio',
+          method: 'listRecords',
+          responseType: typeof responseData.data
+        })
+      }
+
+      return responseData
+    }, DEFAULT_RETRY_POLICY)
+
+    // Determine if more records are available
+    // Attio uses offset-based pagination: hasMore = returned records count equals limit
+    const hasMore = data.data.length === limit
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Records listed: object=${object} recordCount=${data.data.length} limit=${limit} offset=${offset} hasMore=${hasMore} executionId=${context.executionId}`
+      )
+    }
+
+    // Transform to result format
+    return {
+      records: data.data.map((record) => ({
+        id: record.id.record_id,
+        values: record.values,
+        createdAt: record.created_at,
+        webUrl: record.web_url
+      })),
+      hasMore
+    }
+  } catch (error) {
+    // Re-throw ToolingError as-is
+    if (error instanceof ToolingError) {
+      throw error
+    }
+
+    // Wrap unknown errors
+    throw new ToolingError('api_error', `Failed to list Attio records: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'listRecords',
+      organizationId: context?.organizationId,
+      params: { object, filter, sorts, limit, offset }
+    })
+  }
+}

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/update-attribute/index.ts

@@ -0,0 +1,220 @@
+/**
+ * Update Attribute - Attio API
+ *
+ * Updates an existing attribute on an Attio object.
+ * PATCH /v2/objects/{object}/attributes/{attribute}
+ *
+ * Note: Cannot change api_slug or type after creation.
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type {
+  AttioCredentials,
+  UpdateAttributeParams,
+  UpdateAttributeResult,
+  AttioAttributeResponse,
+  AttributeConfig
+} from '../utils/types'
+
+const ATTIO_API_BASE = 'https://api.attio.com/v2'
+
+/**
+ * Update an existing attribute on an Attio object
+ *
+ * Uses PATCH semantics for partial updates. Only fields provided will be updated.
+ * Cannot change api_slug or type after attribute creation.
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Attribute update parameters
+ * @param context - Execution context for logging
+ * @returns Updated attribute ID, slug, and success status
+ * @throws ToolingError if attribute update fails
+ *
+ * @example
+ * // Update attribute title
+ * const updated = await updateAttribute(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     objectSlug: 'people',
+ *     attributeSlug: 'status',
+ *     title: 'Lead Status'
+ *   },
+ *   context
+ * )
+ *
+ * @example
+ * // Archive an attribute
+ * const archived = await updateAttribute(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     objectSlug: 'deals',
+ *     attributeSlug: 'old_field',
+ *     isArchived: true
+ *   },
+ *   context
+ * )
+ *
+ * @example
+ * // Update select options (include existing option IDs to preserve them)
+ * const updated = await updateAttribute(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     objectSlug: 'people',
+ *     attributeSlug: 'stage',
+ *     config: {
+ *       options: [
+ *         { id: 'existing-id-1', title: 'Lead', isArchived: false },
+ *         { id: 'existing-id-2', title: 'Qualified', isArchived: false },
+ *         { title: 'New Stage', isArchived: false }  // New option (no id)
+ *       ]
+ *     }
+ *   },
+ *   context
+ * )
+ */
+export async function updateAttribute(
+  credentials: AttioCredentials,
+  params: UpdateAttributeParams,
+  context?: ExecutionContext
+): Promise<UpdateAttributeResult> {
+  const { apiKey } = credentials
+  const { objectSlug, attributeSlug, title, description, isRequired, isArchived, config } = params
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'updateAttribute',
+      organizationId: context?.organizationId
+    })
+  }
+
+  // Validate required params
+  if (!objectSlug) {
+    throw new ToolingError('validation_error', 'objectSlug is required', {
+      integration: 'attio',
+      method: 'updateAttribute',
+      organizationId: context?.organizationId
+    })
+  }
+  if (!attributeSlug) {
+    throw new ToolingError('validation_error', 'attributeSlug is required', {
+      integration: 'attio',
+      method: 'updateAttribute',
+      organizationId: context?.organizationId
+    })
+  }
+
+  // Ensure at least one field to update
+  if (
+    title === undefined &&
+    description === undefined &&
+    isRequired === undefined &&
+    isArchived === undefined &&
+    config === undefined
+  ) {
+    throw new ToolingError('validation_error', 'At least one field to update is required', {
+      integration: 'attio',
+      method: 'updateAttribute',
+      organizationId: context?.organizationId
+    })
+  }
+
+  const url = `${ATTIO_API_BASE}/objects/${encodeURIComponent(objectSlug)}/attributes/${encodeURIComponent(attributeSlug)}`
+
+  // Build request body with only provided fields (PATCH semantics)
+  const dataPayload: Record<string, unknown> = {}
+  if (title !== undefined) dataPayload.title = title
+  if (description !== undefined) dataPayload.description = description
+  if (isRequired !== undefined) dataPayload.is_required = isRequired
+  if (isArchived !== undefined) dataPayload.is_archived = isArchived
+  if (config !== undefined) dataPayload.config = buildAttributeConfig(config)
+
+  const requestBody = { data: dataPayload }
+
+  try {
+    const data = await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'PATCH',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      })
+
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'updateAttribute',
+          organizationId: context?.organizationId,
+          params: { objectSlug, attributeSlug }
+        })
+      }
+
+      return (await response.json()) as AttioAttributeResponse
+    }, DEFAULT_RETRY_POLICY)
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Attribute updated: objectSlug=${objectSlug} attributeSlug=${attributeSlug} attributeId=${data.data.id.attribute_id} executionId=${context.executionId}`
+      )
+    }
+
+    return {
+      attributeId: data.data.id.attribute_id,
+      slug: data.data.api_slug,
+      success: true
+    }
+  } catch (error) {
+    // Re-throw ToolingError as-is
+    if (error instanceof ToolingError) {
+      throw error
+    }
+
+    // Wrap unknown errors
+    throw new ToolingError('api_error', `Failed to update Attio attribute: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'updateAttribute',
+      organizationId: context?.organizationId,
+      params: { objectSlug, attributeSlug }
+    })
+  }
+}
+
+/**
+ * Build attribute config for API request
+ *
+ * Transforms internal config format to Attio API format.
+ * IMPORTANT: When updating options, include existing option IDs to preserve them.
+ */
+function buildAttributeConfig(config: AttributeConfig): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+
+  // Build select options
+  // IMPORTANT: When updating options, include existing option IDs to preserve them
+  if (config.options) {
+    result.options = config.options.map((opt) => ({
+      ...(opt.id && { id: opt.id }),
+      title: opt.title,
+      is_archived: opt.isArchived
+    }))
+  }
+
+  // Build other config fields
+  if (config.targetObject) {
+    result.target_object = config.targetObject
+  }
+  if (config.currencyCode) {
+    result.currency_code = config.currencyCode
+  }
+  if (config.maxValue !== undefined) {
+    result.max_value = config.maxValue
+  }
+
+  return result
+}