@elevasis/core 0.22.0 → 0.24.0

package/src/execution/engine/tools/integration/server/adapters/apify/apify-adapter.test.ts

@@ -1,55 +1,55 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { ApifyAdapter } from './apify-adapter'
-
-describe('ApifyAdapter', () => {
-  const adapter = new ApifyAdapter()
-  const originalFetch = globalThis.fetch
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-    globalThis.fetch = originalFetch
-  })
-
-  it('accepts Apify tokens stored in provider-specific apiToken shape', () => {
-    expect(adapter.validateCredentials({ apiToken: 'apify_api_test' })).toBe(true)
-  })
-
-  it('accepts Apify tokens stored in generic api-key shape', () => {
-    expect(adapter.validateCredentials({ apiKey: 'apify_api_test' })).toBe(true)
-  })
-
-  it('rejects blank tokens', () => {
-    expect(adapter.validateCredentials({ apiKey: '   ' })).toBe(false)
-  })
-
-  it('verifies credentials against the Apify current-user endpoint', async () => {
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true,
-      json: vi.fn().mockResolvedValue({
-        data: {
-          username: 'elevasis',
-          plan: {
-            id: 'TEAM',
-            description: 'Team plan'
-          }
-        }
-      })
-    })
-    globalThis.fetch = fetchMock as unknown as typeof fetch
-
-    await expect(adapter.verify({ apiKey: ' apify_api_test ' })).resolves.toEqual({
-      ok: true,
-      provider: 'apify',
-      username: 'elevasis',
-      plan: 'TEAM'
-    })
-
-    expect(fetchMock).toHaveBeenCalledWith('https://api.apify.com/v2/users/me', {
-      method: 'GET',
-      headers: {
-        Authorization: 'Bearer apify_api_test',
-        'Content-Type': 'application/json'
-      }
-    })
-  })
-})
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { ApifyAdapter } from './apify-adapter'
+
+describe('ApifyAdapter', () => {
+  const adapter = new ApifyAdapter()
+  const originalFetch = globalThis.fetch
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    globalThis.fetch = originalFetch
+  })
+
+  it('accepts Apify tokens stored in provider-specific apiToken shape', () => {
+    expect(adapter.validateCredentials({ apiToken: 'apify_api_test' })).toBe(true)
+  })
+
+  it('accepts Apify tokens stored in generic api-key shape', () => {
+    expect(adapter.validateCredentials({ apiKey: 'apify_api_test' })).toBe(true)
+  })
+
+  it('rejects blank tokens', () => {
+    expect(adapter.validateCredentials({ apiKey: '   ' })).toBe(false)
+  })
+
+  it('verifies credentials against the Apify current-user endpoint', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue({
+        data: {
+          username: 'elevasis',
+          plan: {
+            id: 'TEAM',
+            description: 'Team plan'
+          }
+        }
+      })
+    })
+    globalThis.fetch = fetchMock as unknown as typeof fetch
+
+    await expect(adapter.verify({ apiKey: ' apify_api_test ' })).resolves.toEqual({
+      ok: true,
+      provider: 'apify',
+      username: 'elevasis',
+      plan: 'TEAM'
+    })
+
+    expect(fetchMock).toHaveBeenCalledWith('https://api.apify.com/v2/users/me', {
+      method: 'GET',
+      headers: {
+        Authorization: 'Bearer apify_api_test',
+        'Content-Type': 'application/json'
+      }
+    })
+  })
+})

package/src/execution/engine/tools/integration/server/adapters/apify/apify-adapter.ts

@@ -1,60 +1,60 @@
 import type { BaseIntegrationAdapter } from '../../../base-integration-adapter'
 import { ToolingError } from '../../../../types'
-import type { ExecutionContext } from '../../../../../base/types'
-import { runActor } from './fetch/run-actor/index'
-import { getDatasetItems } from './fetch/get-dataset-items/index'
-import { startActor } from './fetch/start-actor/index'
-import type { StartActorParams } from '../../../../integration/types/apify'
-import { createHttpError, withRetry, DEFAULT_RETRY_POLICY } from '../../../../../../../platform/resilience'
-
-interface ApifyCredentials {
-  apiToken?: string
-  apiKey?: string
-  api_token?: string
-  token?: string
-}
-
-export interface ApifyVerifyResult {
-  ok: true
-  provider: 'apify'
-  username?: string
-  plan?: string
-}
-
-type ApifyPlan =
-  | string
-  | {
-      id?: string
-      name?: string
-      description?: string
-    }
-
-interface ApifyUserResponse {
-  data?: {
-    username?: string
-    plan?: ApifyPlan
-    id?: string
-  }
-}
-
-interface RunActorParams {
-  actorId: string
-  input?: Record<string, unknown>
-  timeoutSecs?: number
+import type { ExecutionContext } from '../../../../../base/types'
+import { runActor } from './fetch/run-actor/index'
+import { getDatasetItems } from './fetch/get-dataset-items/index'
+import { startActor } from './fetch/start-actor/index'
+import type { StartActorParams } from '../../../../integration/types/apify'
+import { createHttpError, withRetry, DEFAULT_RETRY_POLICY } from '../../../../../../../platform/resilience'
+
+interface ApifyCredentials {
+  apiToken?: string
+  apiKey?: string
+  api_token?: string
+  token?: string
+}
+
+export interface ApifyVerifyResult {
+  ok: true
+  provider: 'apify'
+  username?: string
+  plan?: string
+}
+
+type ApifyPlan =
+  | string
+  | {
+      id?: string
+      name?: string
+      description?: string
+    }
+
+interface ApifyUserResponse {
+  data?: {
+    username?: string
+    plan?: ApifyPlan
+    id?: string
+  }
+}
+
+interface RunActorParams {
+  actorId: string
+  input?: Record<string, unknown>
+  timeoutSecs?: number
   pollIntervalSecs?: number
   maxItems?: number
 }
 
 interface GetDatasetItemsParams {
   datasetId: string
-  maxItems?: number
-  offset?: number
-}
-
-const APIFY_API_BASE_URL = 'https://api.apify.com/v2'
-
-/**
- * Apify integration adapter
+  maxItems?: number
+  offset?: number
+}
+
+const APIFY_API_BASE_URL = 'https://api.apify.com/v2'
+
+/**
+ * Apify integration adapter
  *
  * Provides access to Apify actor automation platform for web scraping
  * and browser automation tasks.
@@ -88,14 +88,14 @@ export class ApifyAdapter implements BaseIntegrationAdapter {
     // Normalize credentials to consistent field name
     const normalizedCreds = this.normalizeCredentials(credentials as unknown as ApifyCredentials)
 
-    // Route to method handler
-    switch (method) {
-      case 'verify':
-        return this.verify(normalizedCreds, context)
-      case 'runActor':
-        return runActor(normalizedCreds, params as RunActorParams, context)
-      case 'getDatasetItems':
-        return getDatasetItems(normalizedCreds, params as GetDatasetItemsParams, context)
+    // Route to method handler
+    switch (method) {
+      case 'verify':
+        return this.verify(normalizedCreds, context)
+      case 'runActor':
+        return runActor(normalizedCreds, params as RunActorParams, context)
+      case 'getDatasetItems':
+        return getDatasetItems(normalizedCreds, params as GetDatasetItemsParams, context)
       case 'startActor':
         return startActor(normalizedCreds, params as StartActorParams, context)
       default:
@@ -107,47 +107,47 @@ export class ApifyAdapter implements BaseIntegrationAdapter {
     }
   }
 
-  validateCredentials(credentials: Record<string, unknown>): boolean {
-    const creds = credentials as unknown as ApifyCredentials
-    const token = creds.apiToken || creds.apiKey || creds.api_token || creds.token
-    return typeof token === 'string' && token.trim().length > 0
-  }
-
-  async verify(credentials: ApifyCredentials, context?: ExecutionContext): Promise<ApifyVerifyResult> {
-    const normalizedCreds = this.normalizeCredentials(credentials)
-    const response = await withRetry(async () => {
-      const result = await fetch(`${APIFY_API_BASE_URL}/users/me`, {
-        method: 'GET',
-        headers: {
-          Authorization: `Bearer ${normalizedCreds.apiToken}`,
-          'Content-Type': 'application/json'
-        }
-      })
-
-      if (!result.ok) {
-        throw await createHttpError(result, {
-          integration: this.name,
-          method: 'verify',
-          organizationId: context?.organizationId
-        })
-      }
-
-      return result
-    }, DEFAULT_RETRY_POLICY)
-
-    const data = (await response.json()) as ApifyUserResponse
-
-    return {
-      ok: true,
-      provider: 'apify',
-      username: data.data?.username ?? data.data?.id,
-      plan: formatApifyPlan(data.data?.plan)
-    }
-  }
-
-  /**
-   * Normalize credentials to use consistent field name
-   */
+  validateCredentials(credentials: Record<string, unknown>): boolean {
+    const creds = credentials as unknown as ApifyCredentials
+    const token = creds.apiToken || creds.apiKey || creds.api_token || creds.token
+    return typeof token === 'string' && token.trim().length > 0
+  }
+
+  async verify(credentials: ApifyCredentials, context?: ExecutionContext): Promise<ApifyVerifyResult> {
+    const normalizedCreds = this.normalizeCredentials(credentials)
+    const response = await withRetry(async () => {
+      const result = await fetch(`${APIFY_API_BASE_URL}/users/me`, {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${normalizedCreds.apiToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      if (!result.ok) {
+        throw await createHttpError(result, {
+          integration: this.name,
+          method: 'verify',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return result
+    }, DEFAULT_RETRY_POLICY)
+
+    const data = (await response.json()) as ApifyUserResponse
+
+    return {
+      ok: true,
+      provider: 'apify',
+      username: data.data?.username ?? data.data?.id,
+      plan: formatApifyPlan(data.data?.plan)
+    }
+  }
+
+  /**
+   * Normalize credentials to use consistent field name
+   */
   private normalizeCredentials(credentials: ApifyCredentials): { apiToken: string } {
     const token = credentials.apiToken || credentials.apiKey || credentials.api_token || credentials.token
     if (!token) {
@@ -155,12 +155,12 @@ export class ApifyAdapter implements BaseIntegrationAdapter {
         integration: this.name
       })
     }
-    return { apiToken: token.trim() }
-  }
-}
-
-function formatApifyPlan(plan: ApifyPlan | undefined): string | undefined {
-  if (!plan) return undefined
-  if (typeof plan === 'string') return plan
-  return plan.id ?? plan.name ?? plan.description
-}
+    return { apiToken: token.trim() }
+  }
+}
+
+function formatApifyPlan(plan: ApifyPlan | undefined): string | undefined {
+  if (!plan) return undefined
+  if (typeof plan === 'string') return plan
+  return plan.id ?? plan.name ?? plan.description
+}

package/src/execution/engine/tools/integration/server/adapters/apollo/apollo-adapter.test.ts

@@ -1,48 +1,48 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { ApolloAdapter } from './apollo-adapter'
-
-describe('ApolloAdapter', () => {
-  const adapter = new ApolloAdapter()
-  const originalFetch = globalThis.fetch
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-    globalThis.fetch = originalFetch
-  })
-
-  it('accepts Apollo API keys stored in generic apiKey shape', () => {
-    expect(adapter.validateCredentials({ apiKey: 'apollo-key' })).toBe(true)
-  })
-
-  it('accepts Apollo API keys stored in legacy Apollo alias shapes', () => {
-    expect(adapter.validateCredentials({ apolloApiKey: 'apollo-key' })).toBe(true)
-    expect(adapter.validateCredentials({ APOLLO_API_KEY: 'apollo-key' })).toBe(true)
-    expect(adapter.validateCredentials({ key: 'apollo-key' })).toBe(true)
-  })
-
-  it('rejects blank tokens', () => {
-    expect(adapter.validateCredentials({ apiKey: '   ' })).toBe(false)
-  })
-
-  it('verifies credentials against the Apollo auth health endpoint', async () => {
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true
-    })
-    globalThis.fetch = fetchMock as unknown as typeof fetch
-
-    await expect(adapter.verify({ apiKey: ' apollo-key ' })).resolves.toEqual({
-      ok: true,
-      provider: 'apollo',
-      authenticated: true
-    })
-
-    expect(fetchMock).toHaveBeenCalledWith('https://api.apollo.io/v1/auth/health', {
-      method: 'GET',
-      headers: {
-        accept: 'application/json',
-        'x-api-key': 'apollo-key',
-        authorization: 'Bearer apollo-key'
-      }
-    })
-  })
-})
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { ApolloAdapter } from './apollo-adapter'
+
+describe('ApolloAdapter', () => {
+  const adapter = new ApolloAdapter()
+  const originalFetch = globalThis.fetch
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    globalThis.fetch = originalFetch
+  })
+
+  it('accepts Apollo API keys stored in generic apiKey shape', () => {
+    expect(adapter.validateCredentials({ apiKey: 'apollo-key' })).toBe(true)
+  })
+
+  it('accepts Apollo API keys stored in legacy Apollo alias shapes', () => {
+    expect(adapter.validateCredentials({ apolloApiKey: 'apollo-key' })).toBe(true)
+    expect(adapter.validateCredentials({ APOLLO_API_KEY: 'apollo-key' })).toBe(true)
+    expect(adapter.validateCredentials({ key: 'apollo-key' })).toBe(true)
+  })
+
+  it('rejects blank tokens', () => {
+    expect(adapter.validateCredentials({ apiKey: '   ' })).toBe(false)
+  })
+
+  it('verifies credentials against the Apollo auth health endpoint', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true
+    })
+    globalThis.fetch = fetchMock as unknown as typeof fetch
+
+    await expect(adapter.verify({ apiKey: ' apollo-key ' })).resolves.toEqual({
+      ok: true,
+      provider: 'apollo',
+      authenticated: true
+    })
+
+    expect(fetchMock).toHaveBeenCalledWith('https://api.apollo.io/v1/auth/health', {
+      method: 'GET',
+      headers: {
+        accept: 'application/json',
+        'x-api-key': 'apollo-key',
+        authorization: 'Bearer apollo-key'
+      }
+    })
+  })
+})

package/src/execution/engine/tools/integration/server/adapters/apollo/apollo-adapter.ts

@@ -1,99 +1,99 @@
-import type { BaseIntegrationAdapter } from '../../../base-integration-adapter'
-import { ToolingError } from '../../../../types'
-import type { ExecutionContext } from '../../../../../base/types'
-import { createHttpError, withRetry, DEFAULT_RETRY_POLICY } from '../../../../../../../platform/resilience'
-
-export interface ApolloCredentials {
-  apiKey?: string
-  apolloApiKey?: string
-  APOLLO_API_KEY?: string
-  key?: string
-  token?: string
-}
-
-export interface ApolloVerifyResult {
-  ok: true
-  provider: 'apollo'
-  authenticated: boolean
-}
-
-const APOLLO_AUTH_HEALTH_URL = 'https://api.apollo.io/v1/auth/health'
-
-export class ApolloAdapter implements BaseIntegrationAdapter {
-  readonly name = 'apollo'
-
-  async call(
-    method: string,
-    params: unknown,
-    credentials: Record<string, unknown>,
-    context?: ExecutionContext
-  ): Promise<unknown> {
-    if (!this.validateCredentials(credentials)) {
-      throw new ToolingError('credentials_invalid', 'Invalid Apollo credentials', {
-        integration: this.name,
-        organizationId: context?.organizationId
-      })
-    }
-
-    switch (method) {
-      case 'verify':
-        return this.verify(credentials as unknown as ApolloCredentials, context)
-      default:
-        throw new ToolingError('method_not_found', `Unknown Apollo method: ${method}`, {
-          integration: this.name,
-          method,
-          organizationId: context?.organizationId
-        })
-    }
-  }
-
-  validateCredentials(credentials: Record<string, unknown>): boolean {
-    const token = this.getToken(credentials as unknown as ApolloCredentials)
-    return typeof token === 'string' && token.trim().length > 0
-  }
-
-  async verify(credentials: ApolloCredentials, context?: ExecutionContext): Promise<ApolloVerifyResult> {
-    const token = this.normalizeCredentials(credentials).apiKey
-    await withRetry(async () => {
-      const response = await fetch(APOLLO_AUTH_HEALTH_URL, {
-        method: 'GET',
-        headers: {
-          accept: 'application/json',
-          'x-api-key': token,
-          authorization: `Bearer ${token}`
-        }
-      })
-
-      if (!response.ok) {
-        throw await createHttpError(response, {
-          integration: this.name,
-          method: 'verify',
-          organizationId: context?.organizationId
-        })
-      }
-
-      return response
-    }, DEFAULT_RETRY_POLICY)
-
-    return {
-      ok: true,
-      provider: 'apollo',
-      authenticated: true
-    }
-  }
-
-  private normalizeCredentials(credentials: ApolloCredentials): { apiKey: string } {
-    const token = this.getToken(credentials)
-    if (!token) {
-      throw new ToolingError('credentials_invalid', 'Missing Apollo API key', {
-        integration: this.name
-      })
-    }
-
-    return { apiKey: token.trim() }
-  }
-
-  private getToken(credentials: ApolloCredentials): string | undefined {
-    return credentials.apiKey ?? credentials.apolloApiKey ?? credentials.APOLLO_API_KEY ?? credentials.key ?? credentials.token
-  }
-}
+import type { BaseIntegrationAdapter } from '../../../base-integration-adapter'
+import { ToolingError } from '../../../../types'
+import type { ExecutionContext } from '../../../../../base/types'
+import { createHttpError, withRetry, DEFAULT_RETRY_POLICY } from '../../../../../../../platform/resilience'
+
+export interface ApolloCredentials {
+  apiKey?: string
+  apolloApiKey?: string
+  APOLLO_API_KEY?: string
+  key?: string
+  token?: string
+}
+
+export interface ApolloVerifyResult {
+  ok: true
+  provider: 'apollo'
+  authenticated: boolean
+}
+
+const APOLLO_AUTH_HEALTH_URL = 'https://api.apollo.io/v1/auth/health'
+
+export class ApolloAdapter implements BaseIntegrationAdapter {
+  readonly name = 'apollo'
+
+  async call(
+    method: string,
+    params: unknown,
+    credentials: Record<string, unknown>,
+    context?: ExecutionContext
+  ): Promise<unknown> {
+    if (!this.validateCredentials(credentials)) {
+      throw new ToolingError('credentials_invalid', 'Invalid Apollo credentials', {
+        integration: this.name,
+        organizationId: context?.organizationId
+      })
+    }
+
+    switch (method) {
+      case 'verify':
+        return this.verify(credentials as unknown as ApolloCredentials, context)
+      default:
+        throw new ToolingError('method_not_found', `Unknown Apollo method: ${method}`, {
+          integration: this.name,
+          method,
+          organizationId: context?.organizationId
+        })
+    }
+  }
+
+  validateCredentials(credentials: Record<string, unknown>): boolean {
+    const token = this.getToken(credentials as unknown as ApolloCredentials)
+    return typeof token === 'string' && token.trim().length > 0
+  }
+
+  async verify(credentials: ApolloCredentials, context?: ExecutionContext): Promise<ApolloVerifyResult> {
+    const token = this.normalizeCredentials(credentials).apiKey
+    await withRetry(async () => {
+      const response = await fetch(APOLLO_AUTH_HEALTH_URL, {
+        method: 'GET',
+        headers: {
+          accept: 'application/json',
+          'x-api-key': token,
+          authorization: `Bearer ${token}`
+        }
+      })
+
+      if (!response.ok) {
+        throw await createHttpError(response, {
+          integration: this.name,
+          method: 'verify',
+          organizationId: context?.organizationId
+        })
+      }
+
+      return response
+    }, DEFAULT_RETRY_POLICY)
+
+    return {
+      ok: true,
+      provider: 'apollo',
+      authenticated: true
+    }
+  }
+
+  private normalizeCredentials(credentials: ApolloCredentials): { apiKey: string } {
+    const token = this.getToken(credentials)
+    if (!token) {
+      throw new ToolingError('credentials_invalid', 'Missing Apollo API key', {
+        integration: this.name
+      })
+    }
+
+    return { apiKey: token.trim() }
+  }
+
+  private getToken(credentials: ApolloCredentials): string | undefined {
+    return credentials.apiKey ?? credentials.apolloApiKey ?? credentials.APOLLO_API_KEY ?? credentials.key ?? credentials.token
+  }
+}

package/src/execution/engine/tools/integration/server/adapters/apollo/index.ts

@@ -1 +1 @@
-export { ApolloAdapter, type ApolloCredentials, type ApolloVerifyResult } from './apollo-adapter'
+export { ApolloAdapter, type ApolloCredentials, type ApolloVerifyResult } from './apollo-adapter'