@elevasis/core 0.7.1 → 0.8.2

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

@@ -1,86 +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
-    })
-  }
-}
+/**
+ * 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

@@ -1,105 +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 }
-    })
-  }
-}
+/**
+ * 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 }
+    })
+  }
+}

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

@@ -1,118 +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 }
-    })
-  }
-}
+/**
+ * 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 }
+    })
+  }
+}