@elevasis/core 0.1.0

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

@@ -0,0 +1,214 @@
+/**
+ * Create Attribute - Attio API
+ *
+ * Creates a new custom attribute (field) on an Attio object.
+ * POST /v2/objects/{object}/attributes
+ */
+
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type {
+  AttioCredentials,
+  CreateAttributeParams,
+  CreateAttributeResult,
+  AttioAttributeResponse,
+  AttributeConfig
+} from '../utils/types'
+
+/**
+ * Create a new attribute on an Attio object
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Attribute creation parameters
+ * @param context - Execution context for logging
+ * @returns Created attribute ID, slug, and success status
+ * @throws ToolingError if attribute creation fails
+ *
+ * @example
+ * // Create a text attribute
+ * const attr = await createAttribute(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     objectSlug: 'people',
+ *     title: 'Lead Source',
+ *     apiSlug: 'lead_source',
+ *     type: 'text'
+ *   },
+ *   context
+ * )
+ *
+ * @example
+ * // Create a select attribute with options
+ * const attr = await createAttribute(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     objectSlug: 'companies',
+ *     title: 'Industry',
+ *     apiSlug: 'industry',
+ *     type: 'select',
+ *     config: {
+ *       options: [
+ *         { title: 'Technology', isArchived: false },
+ *         { title: 'Healthcare', isArchived: false },
+ *         { title: 'Finance', isArchived: false }
+ *       ]
+ *     }
+ *   },
+ *   context
+ * )
+ */
+export async function createAttribute(
+  credentials: AttioCredentials,
+  params: CreateAttributeParams,
+  context?: ExecutionContext
+): Promise<CreateAttributeResult> {
+  const { apiKey } = credentials
+  const { objectSlug, title, apiSlug, type, description, isRequired, isUnique, isMultiselect, config } = params
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Attio API credentials must include apiKey', {
+      integration: 'attio',
+      method: 'createAttribute'
+    })
+  }
+
+  // Validate required parameters
+  if (!objectSlug) {
+    throw new ToolingError('validation_error', 'objectSlug is required', {
+      integration: 'attio',
+      method: 'createAttribute',
+      params: { objectSlug }
+    })
+  }
+  if (!title) {
+    throw new ToolingError('validation_error', 'title is required', {
+      integration: 'attio',
+      method: 'createAttribute',
+      params: { title }
+    })
+  }
+  if (!apiSlug) {
+    throw new ToolingError('validation_error', 'apiSlug is required', {
+      integration: 'attio',
+      method: 'createAttribute',
+      params: { apiSlug }
+    })
+  }
+  if (!type) {
+    throw new ToolingError('validation_error', 'type is required', {
+      integration: 'attio',
+      method: 'createAttribute',
+      params: { type }
+    })
+  }
+
+  // Build URL
+  const url = `https://api.attio.com/v2/objects/${encodeURIComponent(objectSlug)}/attributes`
+
+  // Build request body with nested data structure
+  // Note: Attio API requires description (can be null) and config (empty object for simple types)
+  const requestBody = {
+    data: {
+      title,
+      description: description ?? null,
+      api_slug: apiSlug,
+      type,
+      is_required: isRequired ?? false,
+      is_unique: isUnique ?? false,
+      is_multiselect: isMultiselect ?? false,
+      config: config ? buildAttributeConfig(config) : {}
+    }
+  }
+
+  try {
+    // Execute with retry logic
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      })
+
+      // Handle HTTP errors
+      if (!res.ok) {
+        throw await createHttpError(res, {
+          integration: 'attio',
+          method: 'createAttribute',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return res
+    }, DEFAULT_RETRY_POLICY)
+
+    // Parse response
+    const result = (await response.json()) as AttioAttributeResponse
+
+    // Extract attribute ID from nested structure
+    const attributeId = result.data.id.attribute_id
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Attribute created: attributeId=${attributeId} objectSlug=${objectSlug} title=${title} type=${type} executionId=${context.executionId}`
+      )
+    }
+
+    // Return standardized result
+    return {
+      attributeId,
+      slug: result.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 create Attio attribute: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'createAttribute',
+      organizationId: context?.organizationId,
+      params: { objectSlug, title, type },
+      originalError: error
+    })
+  }
+}
+
+/**
+ * Build attribute config for API request
+ * Transforms camelCase to snake_case for API compatibility
+ */
+function buildAttributeConfig(config: AttributeConfig): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+
+  // Build select options
+  if (config.options) {
+    result.options = config.options.map((opt) => ({
+      ...(opt.id && { id: opt.id }),
+      title: opt.title,
+      is_archived: opt.isArchived ?? false
+    }))
+  }
+
+  // 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
+}

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/create-note/index.ts

@@ -0,0 +1,152 @@
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { AttioCredentials, CreateNoteParams, CreateNoteResult, AttioNoteResponse } from '../utils/types'
+
+/**
+ * Create a new note on an Attio record using native fetch API
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Note creation parameters
+ * @param context - Execution context for logging
+ * @returns Created note ID and success status
+ * @throws ToolingError if note creation fails
+ *
+ * @example
+ * // Create a discovery call note on a person
+ * const note = await createNote(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     parentObject: 'people',
+ *     parentRecordId: '891dcbfc-9141-415d-9b2a-2238a6cc012d',
+ *     title: 'Discovery Call Notes - 2026-01-25',
+ *     format: 'markdown',
+ *     content: '## Summary\n\n- Key point 1\n- Key point 2'
+ *   },
+ *   context
+ * )
+ */
+export async function createNote(
+  credentials: AttioCredentials,
+  params: CreateNoteParams,
+  context?: ExecutionContext
+): Promise<CreateNoteResult> {
+  const { apiKey } = credentials
+  const { parentObject, parentRecordId, title, format, content, createdAt } = params
+
+  // Validate required parameters
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Attio API credentials must include apiKey', {
+      integration: 'attio',
+      method: 'createNote'
+    })
+  }
+
+  if (!parentObject || !parentRecordId || !title || !format || !content) {
+    throw new ToolingError(
+      'validation_error',
+      'parentObject, parentRecordId, title, format, and content are required',
+      {
+        integration: 'attio',
+        method: 'createNote',
+        params: { parentObject, parentRecordId, title, format }
+      }
+    )
+  }
+
+  // Validate format
+  if (format !== 'plaintext' && format !== 'markdown') {
+    throw new ToolingError('validation_error', 'format must be "plaintext" or "markdown"', {
+      integration: 'attio',
+      method: 'createNote',
+      params: { format }
+    })
+  }
+
+  // Build URL
+  const url = 'https://api.attio.com/v2/notes'
+
+  // Build request body
+  const requestBody: {
+    data: {
+      parent_object: string
+      parent_record_id: string
+      title: string
+      format: string
+      content: string
+      created_at?: string
+    }
+  } = {
+    data: {
+      parent_object: parentObject,
+      parent_record_id: parentRecordId,
+      title,
+      format,
+      content
+    }
+  }
+
+  // Add optional createdAt
+  if (createdAt) {
+    requestBody.data.created_at = createdAt
+  }
+
+  try {
+    // Execute with retry logic
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      })
+
+      // Handle HTTP errors
+      if (!res.ok) {
+        throw await createHttpError(res, {
+          integration: 'attio',
+          method: 'createNote',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return res
+    }, DEFAULT_RETRY_POLICY)
+
+    // Parse response
+    const result = (await response.json()) as AttioNoteResponse
+
+    // Extract note ID from nested structure
+    const noteId = result.data.id.note_id
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Note created: noteId=${noteId} parentObject=${parentObject} parentRecordId=${parentRecordId} executionId=${context.executionId}`
+      )
+    }
+
+    // Return standardized result
+    return {
+      noteId,
+      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 create Attio note: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'createNote',
+      organizationId: context?.organizationId,
+      params: { parentObject, parentRecordId, title },
+      originalError: error
+    })
+  }
+}

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

@@ -0,0 +1,141 @@
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { AttioCredentials, CreateRecordParams, CreateRecordResult, AttioRecordResponse } from '../utils/types'
+
+/**
+ * Create a new record in an Attio object using native fetch API
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Record creation parameters (object type and field values)
+ * @param context - Execution context for logging
+ * @returns Created record ID and success status
+ * @throws ToolingError if record creation fails
+ *
+ * @example
+ * // Create a person record
+ * const person = await createRecord(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     object: 'people',
+ *     values: {
+ *       name: {
+ *         first_name: 'John',
+ *         last_name: 'Doe',
+ *         full_name: 'John Doe'
+ *       },
+ *       email_addresses: [
+ *         { email_address: 'john@example.com' }
+ *       ]
+ *     }
+ *   },
+ *   context
+ * )
+ *
+ * @example
+ * // Create a company record
+ * const company = await createRecord(
+ *   { apiKey: 'xxx' },
+ *   {
+ *     object: 'companies',
+ *     values: {
+ *       name: 'Acme Corp',
+ *       domains: [{ domain: 'acme.com' }]
+ *     }
+ *   },
+ *   context
+ * )
+ */
+export async function createRecord(
+  credentials: AttioCredentials,
+  params: CreateRecordParams,
+  context?: ExecutionContext
+): Promise<CreateRecordResult> {
+  const { apiKey } = credentials
+  const { object, values } = params
+
+  // Validate required parameters
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Attio API credentials must include apiKey', {
+      integration: 'attio',
+      method: 'createRecord'
+    })
+  }
+
+  if (!object || !values) {
+    throw new ToolingError('validation_error', 'Object type and values are required', {
+      integration: 'attio',
+      method: 'createRecord',
+      params: { object, values }
+    })
+  }
+
+  // Build URL
+  const url = `https://api.attio.com/v2/objects/${encodeURIComponent(object)}/records`
+
+  // Build request body with nested data.values structure (CRITICAL!)
+  const requestBody = {
+    data: {
+      values
+    }
+  }
+
+  try {
+    // Execute with retry logic
+    const response = await withRetry(async () => {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+          Accept: 'application/json'
+        },
+        body: JSON.stringify(requestBody)
+      })
+
+      // Handle HTTP errors
+      if (!res.ok) {
+        throw await createHttpError(res, {
+          integration: 'attio',
+          method: 'createRecord',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return res
+    }, DEFAULT_RETRY_POLICY)
+
+    // Parse response
+    const result = (await response.json()) as AttioRecordResponse
+
+    // Extract record ID from nested structure
+    const recordId = result.data.id.record_id
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Record created: recordId=${recordId} object=${object} executionId=${context.executionId}`
+      )
+    }
+
+    // Return standardized result
+    return {
+      recordId,
+      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 create Attio record: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'createRecord',
+      organizationId: context?.organizationId,
+      params: { object },
+      originalError: error
+    })
+  }
+}

package/src/execution/engine/tools/integration/server/adapters/attio/fetch/delete-note/index.ts

@@ -0,0 +1,86 @@
+/**
+ * Attio Delete Note - Native Fetch Implementation
+ *
+ * Deletes a single note by ID using native Node.js fetch API.
+ *
+ * API Endpoint: DELETE /v2/notes/{noteId}
+ * Documentation: https://docs.attio.com/rest-api/endpoint-reference/notes/delete-a-note
+ */
+
+import { ToolingError } from '../../../../../../types'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { AttioCredentials, DeleteNoteParams, DeleteNoteResult } from '../utils/types'
+
+/**
+ * Delete a note by ID from Attio
+ *
+ * @param credentials - Attio API credentials (apiKey)
+ * @param params - Note ID to delete
+ * @param context - Execution context for logging
+ * @returns Deleted note ID and success status
+ * @throws ToolingError if deletion fails
+ */
+export async function deleteNote(
+  credentials: AttioCredentials,
+  params: DeleteNoteParams,
+  context?: ExecutionContext
+): Promise<DeleteNoteResult> {
+  const { apiKey } = credentials
+  const { noteId } = params
+
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Attio API credentials must include apiKey', {
+      integration: 'attio',
+      method: 'deleteNote'
+    })
+  }
+
+  if (!noteId) {
+    throw new ToolingError('validation_error', 'noteId is required', {
+      integration: 'attio',
+      method: 'deleteNote',
+      params: { noteId }
+    })
+  }
+
+  const url = `https://api.attio.com/v2/notes/${encodeURIComponent(noteId)}`
+
+  try {
+    await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'DELETE',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'deleteNote',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return await response.json()
+    }, DEFAULT_RETRY_POLICY)
+
+    if (context?.logger) {
+      context.logger.info(`[AttioAdapter] Note deleted: noteId=${noteId} executionId=${context.executionId}`)
+    }
+
+    return { noteId, success: true }
+  } catch (error) {
+    if (error instanceof ToolingError) throw error
+
+    throw new ToolingError('api_error', `Failed to delete Attio note: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'deleteNote',
+      organizationId: context?.organizationId,
+      params: { noteId },
+      originalError: error
+    })
+  }
+}

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

@@ -0,0 +1,105 @@
+/**
+ * Attio Delete Record - Native Fetch Implementation
+ *
+ * Deletes 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: DELETE /v2/objects/{object}/records/{recordId}
+ * Documentation: https://docs.attio.com/rest-api/endpoint-reference/records/delete-a-record
+ */
+
+import { ToolingError } from '../../../../../../types'
+import { withRetry, createHttpError, DEFAULT_RETRY_POLICY } from '../../../../../../../../../platform/resilience'
+import type { ExecutionContext } from '../../../../../../../base/types'
+import type { AttioCredentials, DeleteRecordParams, DeleteRecordResult } from '../utils/types'
+
+/**
+ * Delete 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 Success status with deleted record ID
+ * @throws ToolingError on API errors
+ */
+export async function deleteRecord(
+  credentials: AttioCredentials,
+  params: DeleteRecordParams,
+  context?: ExecutionContext
+): Promise<DeleteRecordResult> {
+  const { object, recordId } = params
+  const { apiKey } = credentials
+
+  // Validate credentials
+  if (!apiKey) {
+    throw new ToolingError('credentials_invalid', 'Missing Attio API key', {
+      integration: 'attio',
+      method: 'deleteRecord'
+    })
+  }
+
+  // Validate parameters
+  if (!object || !recordId) {
+    throw new ToolingError('validation_error', 'Missing required parameters: object and recordId', {
+      integration: 'attio',
+      method: 'deleteRecord',
+      params: { object, recordId }
+    })
+  }
+
+  // Build API URL
+  const url = `https://api.attio.com/v2/objects/${object}/records/${recordId}`
+
+  try {
+    // Execute with retry logic
+    await withRetry(async () => {
+      const response = await fetch(url, {
+        method: 'DELETE',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json'
+        }
+      })
+
+      // Handle HTTP errors
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: 'attio',
+          method: 'deleteRecord',
+          organizationId: context?.organizationId
+        })
+      }
+
+      // Successful deletion returns empty object {}
+      return await response.json()
+    }, DEFAULT_RETRY_POLICY)
+
+    // Log success
+    if (context?.logger) {
+      context.logger.info(
+        `[AttioAdapter] Record deleted: object=${object} recordId=${recordId} executionId=${context.executionId}`
+      )
+    }
+
+    // Return success result
+    return {
+      recordId,
+      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 delete Attio record: ${(error as Error).message}`, {
+      integration: 'attio',
+      method: 'deleteRecord',
+      organizationId: context?.organizationId,
+      params: { object, recordId }
+    })
+  }
+}