@elevasis/core 0.1.0

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

@@ -0,0 +1,186 @@
+/**
+ * Tests for Attio getRecord fetch implementation
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { getRecord } from './index.js'
+import { ToolingError } from '../../../../../../types.js'
+
+// Mock fetch globally
+const mockFetch = vi.fn()
+global.fetch = mockFetch as typeof fetch
+
+describe('getRecord', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should fetch a record successfully', async () => {
+    const mockResponse = {
+      data: {
+        id: {
+          workspace_id: 'workspace-123',
+          object_id: 'object-456',
+          record_id: 'record-789'
+        },
+        created_at: '2024-01-01T12:00:00Z',
+        web_url: 'https://app.attio.com/workspace/record-789',
+        values: {
+          name: [{ first_name: 'John', last_name: 'Doe' }],
+          email: [{ email_address: 'john@example.com' }]
+        }
+      }
+    }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    const result = await getRecord(
+      { apiKey: 'test-key' },
+      { object: 'people', recordId: 'record-789' }
+    )
+
+    expect(result).toEqual({
+      id: 'record-789',
+      values: mockResponse.data.values,
+      createdAt: '2024-01-01T12:00:00Z',
+      webUrl: 'https://app.attio.com/workspace/record-789'
+    })
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.attio.com/v2/objects/people/records/record-789',
+      expect.objectContaining({
+        method: 'GET',
+        headers: {
+          'Authorization': 'Bearer test-key',
+          'Accept': 'application/json'
+        }
+      })
+    )
+  })
+
+  it('should throw credentials_invalid when API key is missing', async () => {
+    await expect(
+      getRecord(
+        { apiKey: '' },
+        { object: 'people', recordId: 'record-123' }
+      )
+    ).rejects.toThrow(ToolingError)
+
+    await expect(
+      getRecord(
+        { apiKey: '' },
+        { object: 'people', recordId: 'record-123' }
+      )
+    ).rejects.toThrow('Missing Attio API key')
+  })
+
+  it('should throw validation_error when parameters are missing', async () => {
+    await expect(
+      getRecord(
+        { apiKey: 'test-key' },
+        { object: '', recordId: 'record-123' }
+      )
+    ).rejects.toThrow(ToolingError)
+
+    await expect(
+      getRecord(
+        { apiKey: 'test-key' },
+        { object: 'people', recordId: '' }
+      )
+    ).rejects.toThrow('Missing required parameters')
+  })
+
+  it('should handle 404 not found errors', async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+      text: async () => JSON.stringify({
+        status_code: 404,
+        type: 'invalid_request_error',
+        code: 'not_found',
+        message: 'Record not found'
+      })
+    })
+
+    await expect(
+      getRecord(
+        { apiKey: 'test-key' },
+        { object: 'people', recordId: 'nonexistent' }
+      )
+    ).rejects.toThrow(ToolingError)
+
+    try {
+      await getRecord(
+        { apiKey: 'test-key' },
+        { object: 'people', recordId: 'nonexistent' }
+      )
+    } catch (error) {
+      expect((error as ToolingError).errorType).toBe('validation_error')
+      expect((error as ToolingError).message).toContain('Record not found')
+    }
+  })
+
+  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 getRecord(
+        { apiKey: 'invalid-key' },
+        { object: 'people', recordId: 'record-123' }
+      )
+    } catch (error) {
+      expect((error as ToolingError).errorType).toBe('credentials_invalid')
+      expect((error as ToolingError).message).toContain('Invalid API key')
+    }
+  })
+
+  it('should work with different object types', async () => {
+    const mockResponse = {
+      data: {
+        id: {
+          workspace_id: 'workspace-123',
+          object_id: 'object-456',
+          record_id: 'company-789'
+        },
+        created_at: '2024-01-01T12:00:00Z',
+        web_url: 'https://app.attio.com/workspace/company-789',
+        values: {
+          name: 'Acme Corp',
+          domains: [{ domain: 'acme.com' }]
+        }
+      }
+    }
+
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => mockResponse
+    })
+
+    const result = await getRecord(
+      { apiKey: 'test-key' },
+      { object: 'companies', recordId: 'company-789' }
+    )
+
+    expect(result.id).toBe('company-789')
+    expect(result.values.name).toBe('Acme Corp')
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://api.attio.com/v2/objects/companies/records/company-789',
+      expect.anything()
+    )
+  })
+})

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/get-record/index.ts

@@ -0,0 +1,118 @@
+/**
+ * Attio Get Record - Native Fetch Implementation
+ *
+ * Fetches a single record by ID from an Attio object using native Node.js fetch API.
+ * Supports all object types: people, companies, deals, and custom objects.
+ *
+ * API Endpoint: GET /v2/objects/{object}/records/{recordId}
+ * Documentation: https://developers.attio.com/reference/get-record
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type { AttioCredentials, GetRecordParams, GetRecordResult, AttioRecordResponse } from '../utils/types'
+
+/**
+ * Get a single record by ID from an Attio object
+ *
+ * Uses native Node.js fetch API with retry logic for resilience.
+ *
+ * @param credentials - Attio API credentials (Bearer token)
+ * @param params - Object type and record ID
+ * @param context - Execution context for logging
+ * @returns Record data with ID, values, createdAt, and webUrl
+ * @throws ToolingError on API errors
+ */
+export async function getRecord(
+  credentials: AttioCredentials,
+  params: GetRecordParams,
+  context?: ExecutionContext
+): Promise<GetRecordResult> {
+  const { object, recordId } = params
+  const { apiKey } = credentials
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'getRecord'
+    })
+  }
+
+  // Validate parameters
+  if (!object || !recordId) {
+    throw new ToolingError('validation_error', 'Missing required parameters: object and recordId', {
+      integration: 'attio',
+      method: 'getRecord',
+      params: { object, recordId }
+    })
+  }
+
+  // Build API URL
+  const url = `https://api.attio.com/v2/objects/${object}/records/${recordId}`
+
+  try {
+    // Execute with retry logic
+    const data = await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'getRecord',
+          organizationId: context?.organizationId
+        })
+      }
+
+      // Parse response
+      const responseData = (await response.json()) as AttioRecordResponse
+
+      // Validate response structure
+      if (!responseData.data || !responseData.data.id || !responseData.data.id.record_id) {
+        throw new ToolingError('api_error', 'Invalid response format: missing record ID', {
+          integration: 'attio',
+          method: 'getRecord',
+          responseData
+        })
+      }
+
+      return responseData
+    }, DEFAULT_RETRY_POLICY)
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Record retrieved: object=${object} recordId=${data.data.id.record_id} executionId=${context.executionId}`
+      )
+    }
+
+    // Transform to result format
+    return {
+      id: data.data.id.record_id,
+      values: data.data.values,
+      createdAt: data.data.created_at,
+      webUrl: data.data.web_url
+    }
+  } catch (error) {
+    // Re-throw ToolingError as-is
+    if (error instanceof ToolingError) {
+      throw error
+    }
+
+    // Wrap unknown errors
+    throw new ToolingError('api_error', `Failed to get Attio record: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'getRecord',
+      organizationId: context?.organizationId,
+      params: { object, recordId }
+    })
+  }
+}

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

@@ -0,0 +1,165 @@
+/**
+ * List Attributes - Attio API
+ *
+ * Lists all attributes (fields) for a specific object.
+ * GET /v2/objects/{object}/attributes
+ *
+ * Documentation: https://developers.attio.com/reference/get-attributes
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type {
+  AttioCredentials,
+  ListAttributesParams,
+  ListAttributesResult,
+  AttioAttributesListResponse,
+  AttioAttributeType
+} from '../utils/types'
+
+/**
+ * List all attributes for an Attio object
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Object slug to list attributes for
+ * @param context - Execution context for logging
+ * @returns List of attributes with metadata and configuration
+ * @throws ToolingError if API call fails
+ *
+ * @example
+ * const result = await listAttributes(
+ *   { apiKey: 'xxx' },
+ *   { objectSlug: 'people' },
+ *   context
+ * )
+ * // result.attributes = [{ id: '...', slug: 'name', type: 'text', ... }, ...]
+ */
+export async function listAttributes(
+  credentials: AttioCredentials,
+  params: ListAttributesParams,
+  context?: ExecutionContext
+): Promise<ListAttributesResult> {
+  const { apiKey } = credentials
+  const { objectSlug } = params
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'listAttributes',
+      organizationId: context?.organizationId
+    })
+  }
+
+  // Validate parameters
+  if (!objectSlug) {
+    throw new ToolingError('validation_error', 'objectSlug is required', {
+      integration: 'attio',
+      method: 'listAttributes',
+      organizationId: context?.organizationId
+    })
+  }
+
+  // Build URL
+  const url = `https://api.attio.com/v2/objects/${encodeURIComponent(objectSlug)}/attributes`
+
+  try {
+    // Execute with retry logic
+    const data = await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'listAttributes',
+          organizationId: context?.organizationId,
+          params: { objectSlug }
+        })
+      }
+
+      return (await response.json()) as AttioAttributesListResponse
+    }, DEFAULT_RETRY_POLICY)
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Attributes listed: objectSlug=${objectSlug} attributeCount=${data.data.length} executionId=${context.executionId}`
+      )
+    }
+
+    // Transform response to clean format
+    return {
+      attributes: data.data.map((attr) => ({
+        id: attr.id.attribute_id,
+        slug: attr.api_slug,
+        title: attr.title,
+        description: attr.description,
+        type: attr.type as AttioAttributeType,
+        isSystemAttribute: attr.is_system_attribute,
+        isRequired: attr.is_required,
+        isUnique: attr.is_unique,
+        isMultiselect: attr.is_multiselect,
+        isArchived: attr.is_archived,
+        config: attr.config ? parseAttributeConfig(attr.config) : undefined
+      }))
+    }
+  } 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 attributes: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'listAttributes',
+      organizationId: context?.organizationId,
+      params: { objectSlug }
+    })
+  }
+}
+
+/**
+ * Parse attribute config from API response
+ *
+ * Transforms snake_case API response to camelCase internal format.
+ * Handles type-specific configuration fields.
+ */
+function parseAttributeConfig(config: Record<string, unknown>) {
+  const result: {
+    options?: Array<{ id?: string; title: string; isArchived: boolean }>
+    targetObject?: string
+    currencyCode?: string
+    maxValue?: number
+  } = {}
+
+  // Parse select options
+  if (Array.isArray(config.options)) {
+    result.options = config.options.map((opt: { id?: string; title: string; is_archived?: boolean }) => ({
+      id: opt.id,
+      title: opt.title,
+      isArchived: opt.is_archived ?? false
+    }))
+  }
+
+  // Parse other config fields
+  if (typeof config.target_object === 'string') {
+    result.targetObject = config.target_object
+  }
+  if (typeof config.currency_code === 'string') {
+    result.currencyCode = config.currency_code
+  }
+  if (typeof config.max_value === 'number') {
+    result.maxValue = config.max_value
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined
+}

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

@@ -0,0 +1,96 @@
+/**
+ * Attio List Notes - Native Fetch Implementation
+ *
+ * Lists notes attached to a specific Attio record using native Node.js fetch API.
+ *
+ * API Endpoint: GET /v2/notes?parent_object={object}&parent_record_id={recordId}
+ * Documentation: https://docs.attio.com/rest-api/endpoint-reference/notes/list-notes
+ */
+
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { AttioCredentials, ListNotesParams, ListNotesResult, AttioNotesListResponse } from '../utils/types'
+
+/**
+ * List notes attached to an Attio record
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Parent object and record ID to list notes for
+ * @param context - Execution context for logging
+ * @returns Array of notes with noteId, title, and createdAt
+ * @throws ToolingError if listing fails
+ */
+export async function listNotes(
+  credentials: AttioCredentials,
+  params: ListNotesParams,
+  context?: ExecutionContext
+): Promise<ListNotesResult> {
+  const { apiKey } = credentials
+  const { parentObject, parentRecordId } = params
+
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Attio API credentials must include apiKey', {
+      integration: 'attio',
+      method: 'listNotes'
+    })
+  }
+
+  if (!parentObject || !parentRecordId) {
+    throw new ToolingError('validation_error', 'parentObject and parentRecordId are required', {
+      integration: 'attio',
+      method: 'listNotes',
+      params: { parentObject, parentRecordId }
+    })
+  }
+
+  const url = `https://api.attio.com/v2/notes?parent_object=${encodeURIComponent(parentObject)}&parent_record_id=${encodeURIComponent(parentRecordId)}`
+
+  try {
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      if (!res.ok) {
+        throw await createHttpError(res, {
+          integration: 'attio',
+          method: 'listNotes',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return res
+    }, DEFAULT_RETRY_POLICY)
+
+    const result = (await response.json()) as AttioNotesListResponse
+
+    const notes = result.data.map((note) => ({
+      noteId: note.id.note_id,
+      title: note.title,
+      createdAt: note.created_at
+    }))
+
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Notes listed: parentObject=${parentObject} parentRecordId=${parentRecordId} count=${notes.length} executionId=${context.executionId}`
+      )
+    }
+
+    return { notes, success: true }
+  } catch (error) {
+    if (error instanceof ToolingError) throw error
+
+    throw new ToolingError('api_error', `Failed to list Attio notes: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'listNotes',
+      organizationId: context?.organizationId,
+      params: { parentObject, parentRecordId },
+      originalError: error
+    })
+  }
+}

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

@@ -0,0 +1,104 @@
+/**
+ * List Objects - Attio API
+ *
+ * Lists all objects (people, companies, deals, custom) in the workspace.
+ * GET /v2/objects
+ *
+ * Documentation: https://developers.attio.com/reference/get-objects
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type { AttioCredentials, ListObjectsParams, ListObjectsResult, AttioObjectsListResponse } from '../utils/types'
+
+/**
+ * List all objects in the Attio workspace
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param _params - Empty parameters object (all objects are returned)
+ * @param context - Execution context for logging
+ * @returns List of objects with id, slug, singular/plural nouns, and createdAt
+ * @throws ToolingError if API call fails
+ *
+ * @example
+ * const result = await listObjects(
+ *   { apiKey: 'xxx' },
+ *   {},
+ *   context
+ * )
+ * // result.objects = [{ id: '...', slug: 'people', ... }, ...]
+ */
+export async function listObjects(
+  credentials: AttioCredentials,
+  _params: ListObjectsParams,
+  context?: ExecutionContext
+): Promise<ListObjectsResult> {
+  const { apiKey } = credentials
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'listObjects',
+      organizationId: context?.organizationId
+    })
+  }
+
+  // Build URL
+  const url = 'https://api.attio.com/v2/objects'
+
+  try {
+    // Execute with retry logic
+    const data = await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'listObjects',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return (await response.json()) as AttioObjectsListResponse
+    }, DEFAULT_RETRY_POLICY)
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Objects listed: objectCount=${data.data.length} executionId=${context.executionId}`
+      )
+    }
+
+    // Transform response to clean format
+    return {
+      objects: data.data.map((obj) => ({
+        id: obj.id.object_id,
+        slug: obj.api_slug,
+        singularNoun: obj.singular_noun,
+        pluralNoun: obj.plural_noun,
+        createdAt: obj.created_at
+      }))
+    }
+  } 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 objects: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'listObjects',
+      organizationId: context?.organizationId
+    })
+  }
+}