@commandable/integration-data 0.5.0 → 0.6.0

package/integrations/__tests__/liveHarness.ts

@@ -1,97 +0,0 @@
-import { IntegrationProxy } from '../../../core/src/integrations/proxy.js'
-import { loadIntegrationTools } from '../../../core/src/integrations/dataLoader.js'
-import { createSafeHandlerFromString } from '../../../core/src/integrations/sandbox.js'
-import { buildSandboxUtils } from '../../../core/src/integrations/sandboxUtils.js'
-
-type ToolDef = {
-  name: string
-  handlerCode: string
-  utils?: string[]
-}
-
-type ToolSet = {
-  read: ToolDef[]
-  write: ToolDef[]
-  admin: ToolDef[]
-}
-
-export function hasEnv(...keys: string[]) {
-  const env = process.env as Record<string, string | undefined>
-  return keys.every(k => Boolean(env[k] && String(env[k]).trim().length > 0))
-}
-
-export function safeCleanup(fn: () => Promise<any>) {
-  return fn().catch(() => {})
-}
-
-export function createCredentialStore(getCredentials: () => Promise<any>) {
-  return { getCredentials }
-}
-
-export function createIntegrationNode(type: string, opts?: { id?: string, label?: string, credentialId?: string, credentialVariant?: string }) {
-  const id = opts?.id || `node-${type}`
-  return {
-    spaceId: 'ci',
-    id,
-    referenceId: id,
-    type,
-    label: opts?.label || type,
-    connectionMethod: 'credentials',
-    credentialId: opts?.credentialId || `${type}-creds`,
-    credentialVariant: opts?.credentialVariant,
-  } as any
-}
-
-export function createProxy(credentialStore: { getCredentials: () => Promise<any> }) {
-  return new IntegrationProxy({ credentialStore })
-}
-
-function getTools(type: string, credentialVariant?: string): ToolSet {
-  const tools = loadIntegrationTools(type, { credentialVariant })
-  if (!tools)
-    throw new Error(`Missing integration tools for '${type}'`)
-  return tools as any
-}
-
-function compileTool(proxy: IntegrationProxy, node: any, tool: ToolDef) {
-  const integration = { fetch: (path: string, init?: RequestInit) => proxy.call(node, path, init) }
-  const wrapper = `async (input) => {\n  const integration = getIntegration('${String(node?.id || 'node')}');\n  const __inner = ${tool.handlerCode};\n  return await __inner(input);\n}`
-  const utils = buildSandboxUtils(Array.isArray(tool.utils) ? tool.utils : undefined)
-  const safeHandler = createSafeHandlerFromString(wrapper, () => integration, utils)
-  return async (input: any) => {
-    const res = await safeHandler(input)
-    if (!res.success)
-      throw res.result
-    return res.result
-  }
-}
-
-export function createToolbox(type: string, proxy: IntegrationProxy, node: any, credentialVariant?: string) {
-  const tools = getTools(type, credentialVariant)
-
-  const findTool = (scope: keyof ToolSet, name: string) => tools[scope].find(t => t.name === name)
-
-  return {
-    /** Returns true if the tool exists in this variant's toolset. */
-    hasTool: (scope: keyof ToolSet, name: string) => !!findTool(scope, name),
-
-    read: (name: string) => {
-      const tool = findTool('read', name)
-      if (!tool)
-        throw new Error(`Missing read tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
-      return compileTool(proxy, node, tool)
-    },
-    write: (name: string) => {
-      const tool = findTool('write', name)
-      if (!tool)
-        throw new Error(`Missing write tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
-      return compileTool(proxy, node, tool)
-    },
-    admin: (name: string) => {
-      const tool = findTool('admin', name) || findTool('write', name) || findTool('read', name)
-      if (!tool)
-        throw new Error(`Missing admin tool '${name}' for '${type}' (variant: ${credentialVariant ?? 'default'})`)
-      return compileTool(proxy, node, tool)
-    },
-  }
-}

package/integrations/__tests__/usageParity.ts

@@ -1,54 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { loadIntegrationManifest } from '../../../core/src/integrations/dataLoader.js'
-
-function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-/**
- * Returns tool names from the manifest that are not exercised in any test file,
- * excluding tools that are restricted to specific credential variants (those are
- * covered by their own variant-specific test suites).
- */
-export function getMissingToolUsages(opts: { integrationName: string, importMetaUrl: string, credentialVariant?: string }): string[] {
-  const manifest = loadIntegrationManifest(opts.integrationName)
-  if (!manifest)
-    throw new Error(`Missing integration manifest for '${opts.integrationName}'`)
-
-  const tools = manifest.tools as any[]
-
-  const relevantTools = tools.filter((t) => {
-    if (!t.credentialVariants || !Array.isArray(t.credentialVariants) || t.credentialVariants.length === 0)
-      return true
-    if (opts.credentialVariant)
-      return t.credentialVariants.includes(opts.credentialVariant)
-    return false
-  })
-
-  const toolNames = relevantTools.map(t => t.name)
-
-  const testsDir = fileURLToPath(new URL('.', opts.importMetaUrl))
-  if (!existsSync(testsDir))
-    throw new Error(`Missing tests directory: ${testsDir}`)
-
-  const testFiles = readdirSync(testsDir)
-    .filter(f => /\.test\.(t|j)s$/.test(f) && !f.includes('usage_parity.test'))
-    .map(f => resolve(testsDir, f))
-
-  const fileContents = testFiles.map(f => readFileSync(f, 'utf8'))
-
-  const missing: string[] = []
-  for (const name of toolNames) {
-    const nameRe = new RegExp(
-      `(?:build(?:Read|Write|Admin)?(?:Handler)?|\\.(?:read|write|admin))\\(\\s*['\"\`]${escapeRegExp(name)}['\"\`]\\s*\\)`,
-      'm',
-    )
-    const found = fileContents.some(src => nameRe.test(src))
-    if (!found)
-      missing.push(name)
-  }
-
-  return missing
-}

package/integrations/airtable/.env.test.example

@@ -1,11 +0,0 @@
-# Airtable live integration tests
-#
-# Get a personal access token at: https://airtable.com/create/tokens
-# Ensure it has access to the base below with data.records:read + data.records:write.
-AIRTABLE_TOKEN=
-#
-# Required for write tests (the suite creates/updates/deletes records; it does NOT create
-# bases/tables). Base/table IDs can be found in the Airtable UI/API docs for your base.
-# The table must have a writable text field named `Name`.
-AIRTABLE_TEST_WRITE_BASE_ID=
-AIRTABLE_TEST_WRITE_TABLE_ID=

package/integrations/airtable/README.md

@@ -1,27 +0,0 @@
-# Airtable
-
-**11 tools**
-
-![Airtable tests](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/theomccabe/771bd329f303087690c522afa1baa6f3/raw/test-airtable.json)
-
-## Credential variants
-
-| Variant | Label |
-|---|---|
-| `personal_access_token` | Personal Access Token _(default)_ |
-
-## Tools
-
-| Tool | Scope | Description |
-|---|---|---|
-| `list_bases` | read | List bases available to the authenticated user. |
-| `list_tables` | read | List tables in a base (metadata). |
-| `get_table_schema` | read | Fetch a table's schema (fields, views) by tableId via metadata. |
-| `list_table_fields` | read | List fields for a table (metadata). |
-| `list_views` | read | List views for a table (metadata). |
-| `list_records` | read | List records from a table with optional filters. |
-| `get_record` | read | Fetch a single record by recordId. |
-| `search_records` | read | Search records in a table using a field and value (filterByFormula). |
-| `create_record` | write | Create a record in a table. |
-| `update_record` | write | Update a record in a table. |
-| `delete_record` | write | Delete a record from a table. |

package/integrations/airtable/__tests__/get_handlers.test.ts

@@ -1,187 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { IntegrationProxy } from '../../../../core/src/integrations/proxy.js'
-import { loadIntegrationTools } from '../../../../core/src/integrations/dataLoader.js'
-
-// LIVE Airtable integration tests using credentials
-// Required env vars:
-// - AIRTABLE_TOKEN
-// Optional (pins read tests to a specific base/table instead of auto-discovering):
-// - AIRTABLE_TEST_WRITE_BASE_ID
-// - AIRTABLE_TEST_WRITE_TABLE_ID
-
-interface Ctx {
-  baseId?: string
-  tableId?: string
-  recordId?: string
-  ownedRecordId?: string
-}
-
-const env = process.env as Record<string, string>
-const hasEnv = (...keys: string[]) => keys.every(k => !!env[k] && env[k].trim().length > 0)
-const suite = hasEnv(
-  'AIRTABLE_TOKEN',
-)
-  ? describe
-  : describe.skip
-
-suite('airtable read handlers (live)', () => {
-  const ctx: Ctx = {}
-  let buildHandler: (name: string) => ((input: any) => Promise<any>)
-  let buildWriteHandler: (name: string) => ((input: any) => Promise<any>)
-
-  beforeAll(async () => {
-    const credentialStore = {
-      getCredentials: async () => ({ token: env.AIRTABLE_TOKEN || '' }),
-    }
-
-    const proxy = new IntegrationProxy({ credentialStore })
-    const integrationNode = {
-      spaceId: 'ci',
-      id: 'node-airtable',
-      referenceId: 'node-airtable',
-      type: 'airtable',
-      label: 'Airtable',
-      connectionMethod: 'credentials',
-      credentialId: 'airtable-creds',
-    } as any
-
-    const tools = loadIntegrationTools('airtable')
-    expect(tools).toBeTruthy()
-
-    buildHandler = (name: string) => {
-      const tool = tools!.read.find(t => t.name === name)
-      expect(tool, `tool ${name} exists`).toBeTruthy()
-      const integration = {
-        fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init),
-      }
-      const build = new Function('integration', `return (${tool!.handlerCode});`)
-      return build(integration) as (input: any) => Promise<any>
-    }
-
-    buildWriteHandler = (name: string) => {
-      const tool = tools!.write.find(t => t.name === name)
-      expect(tool, `write tool ${name} exists`).toBeTruthy()
-      const integration = {
-        fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init),
-      }
-      const build = new Function('integration', `return (${tool!.handlerCode});`)
-      return build(integration) as (input: any) => Promise<any>
-    }
-
-    // Use explicit test base/table if provided, otherwise auto-discover from first base
-    if (env.AIRTABLE_TEST_WRITE_BASE_ID && env.AIRTABLE_TEST_WRITE_TABLE_ID) {
-      ctx.baseId = env.AIRTABLE_TEST_WRITE_BASE_ID
-      ctx.tableId = env.AIRTABLE_TEST_WRITE_TABLE_ID
-    }
-    else {
-      const list_bases = buildHandler('list_bases')
-      const bases = await list_bases({})
-      ctx.baseId = bases?.bases?.[0]?.id || bases?.[0]?.id
-
-      if (ctx.baseId) {
-        const list_tables = buildHandler('list_tables')
-        const tablesResp = await list_tables({ baseId: ctx.baseId })
-        const tables = tablesResp?.tables || tablesResp
-        ctx.tableId = tables?.[0]?.id
-      }
-    }
-
-    // Create a dedicated record so get_record has a stable ID that the concurrent
-    // write suite cannot accidentally delete out from under us.
-    if (ctx.baseId && ctx.tableId) {
-      try {
-        const create_record = buildWriteHandler('create_record')
-        const created = await create_record({
-          baseId: ctx.baseId,
-          tableId: ctx.tableId,
-          fields: { Name: `ReadTest ${Date.now()}` },
-        })
-        const rec = created?.records?.[0] || created
-        ctx.ownedRecordId = rec?.id
-        ctx.recordId = rec?.id
-      }
-      catch {
-        // If create fails (e.g. no write permission), fall back to discovering a record
-        const list_records = buildHandler('list_records')
-        const recs = await list_records({ baseId: ctx.baseId, tableId: ctx.tableId, pageSize: 1 })
-        const records = recs?.records || recs
-        ctx.recordId = records?.[0]?.id
-      }
-    }
-  }, 60000)
-
-  afterAll(async () => {
-    if (ctx.ownedRecordId && ctx.baseId && ctx.tableId) {
-      try {
-        const delete_record = buildWriteHandler('delete_record')
-        await delete_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.ownedRecordId })
-      }
-      catch {}
-    }
-  })
-
-  it('list_bases returns bases', async () => {
-    const handler = buildHandler('list_bases')
-    const result = await handler({})
-    expect(result).toBeTruthy()
-  }, 30000)
-
-  it('list_tables returns tables for base', async () => {
-    if (!ctx.baseId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_tables')
-    const result = await handler({ baseId: ctx.baseId })
-    expect(result).toBeTruthy()
-  }, 30000)
-
-  it('get_table_schema returns a table schema', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('get_table_schema')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
-    expect(result?.id || result?.name).toBeTruthy()
-  }, 30000)
-
-  it('list_table_fields returns fields', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_table_fields')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
-
-  it('list_views returns views', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_views')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId })
-    expect(Array.isArray(result)).toBe(true)
-  }, 30000)
-
-  it('list_records returns records', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('list_records')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, pageSize: 3 })
-    expect(result).toBeTruthy()
-  }, 30000)
-
-  it('get_record returns a record by id', async () => {
-    if (!ctx.baseId || !ctx.tableId || !ctx.recordId)
-      return expect(true).toBe(true)
-    const handler = buildHandler('get_record')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.recordId })
-    expect(result?.id).toBe(ctx.recordId)
-  }, 30000)
-
-  it('search_records returns matching records', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-    const list_fields = buildHandler('list_table_fields')
-    const fields: any[] = await list_fields({ baseId: ctx.baseId, tableId: ctx.tableId })
-    const fieldName = fields?.[0]?.name || 'Name'
-    const handler = buildHandler('search_records')
-    const result = await handler({ baseId: ctx.baseId, tableId: ctx.tableId, field: fieldName, value: '' })
-    expect(result).toBeTruthy()
-  }, 30000)
-})

package/integrations/airtable/__tests__/usage_parity.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { getMissingToolUsages } from '../../__tests__/usageParity.js'
-
-describe('airtable static usage parity', () => {
-  it('every manifest tool is referenced in tests', () => {
-    const missing = getMissingToolUsages({ integrationName: 'airtable', importMetaUrl: import.meta.url })
-    expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
-  })
-})

package/integrations/airtable/__tests__/write_and_admin_handlers.test.ts

@@ -1,116 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest'
-import { IntegrationProxy } from '../../../../core/src/integrations/proxy.js'
-import { loadIntegrationTools } from '../../../../core/src/integrations/dataLoader.js'
-
-// LIVE Airtable write tests using credentials
-// Required env vars:
-// - AIRTABLE_TOKEN
-// Optional env for choosing base/table (otherwise picks first available):
-// - AIRTABLE_TEST_WRITE_BASE_ID
-// - AIRTABLE_TEST_WRITE_TABLE_ID
-
-interface Ctx {
-  baseId?: string
-  tableId?: string
-  createdRecordId?: string
-}
-
-const env = process.env as Record<string, string>
-const hasEnv = (...keys: string[]) => keys.every(k => !!env[k] && env[k].trim().length > 0)
-const suite = hasEnv(
-  'AIRTABLE_TOKEN',
-)
-  ? describe
-  : describe.skip
-
-suite('airtable write handlers (live)', () => {
-  const ctx: Ctx = {}
-  let buildWriteHandler: (name: string) => ((input: any) => Promise<any>)
-  let buildReadHandler: (name: string) => ((input: any) => Promise<any>)
-
-  beforeAll(async () => {
-    const credentialStore = {
-      getCredentials: async () => ({ token: env.AIRTABLE_TOKEN || '' }),
-    }
-
-    const proxy = new IntegrationProxy({ credentialStore })
-    const integrationNode = {
-      spaceId: 'ci',
-      id: 'node-airtable',
-      referenceId: 'node-airtable',
-      type: 'airtable',
-      label: 'Airtable',
-      connectionMethod: 'credentials',
-      credentialId: 'airtable-creds',
-    } as any
-
-    const tools = loadIntegrationTools('airtable')
-    expect(tools).toBeTruthy()
-
-    buildWriteHandler = (name: string) => {
-      const tool = tools!.write.find(t => t.name === name)
-      expect(tool, `write tool ${name} exists`).toBeTruthy()
-      const integration = { fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init) }
-      const build = new Function('integration', `return (${tool!.handlerCode});`)
-      return build(integration) as (input: any) => Promise<any>
-    }
-
-    buildReadHandler = (name: string) => {
-      const tool = tools!.read.find(t => t.name === name)
-      expect(tool, `read tool ${name} exists`).toBeTruthy()
-      const integration = { fetch: (path: string, init?: RequestInit) => proxy.call(integrationNode, path, init) }
-      const build = new Function('integration', `return (${tool!.handlerCode});`)
-      return build(integration) as (input: any) => Promise<any>
-    }
-
-    // Resolve base/table for write tests
-    ctx.baseId = env.AIRTABLE_TEST_WRITE_BASE_ID
-    ctx.tableId = env.AIRTABLE_TEST_WRITE_TABLE_ID
-
-    if (!ctx.baseId || !ctx.tableId) {
-      const list_bases = buildReadHandler('list_bases')
-      const bases = await list_bases({})
-      ctx.baseId = ctx.baseId || (bases?.bases?.[0]?.id || bases?.[0]?.id)
-      if (ctx.baseId) {
-        const list_tables = buildReadHandler('list_tables')
-        const tablesResp = await list_tables({ baseId: ctx.baseId })
-        const tables = tablesResp?.tables || tablesResp
-        ctx.tableId = ctx.tableId || tables?.[0]?.id
-      }
-    }
-  }, 60000)
-
-  it('create_record -> get_record -> update_record -> delete_record roundtrip', async () => {
-    if (!ctx.baseId || !ctx.tableId)
-      return expect(true).toBe(true)
-
-    // Assume a single writable column named 'Name' per test setup
-    const fieldName = 'Name'
-
-    // Create
-    const create_record = buildWriteHandler('create_record')
-    const created = await create_record({ baseId: ctx.baseId, tableId: ctx.tableId, fields: { [fieldName]: `CmdTest ${Date.now()}` } })
-    const createdRec = created?.records?.[0] || created
-    expect(createdRec?.id).toBeTruthy()
-    ctx.createdRecordId = createdRec.id
-
-    // Read
-    const get_record = buildReadHandler('get_record')
-    const got = await get_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId })
-    expect(got?.id).toBe(ctx.createdRecordId)
-
-    // Update
-    const update_record = buildWriteHandler('update_record')
-    const updated = await update_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId, fields: { [fieldName]: `CmdTest Updated ${Date.now()}` } })
-    const updatedRec = updated?.records?.[0] || updated
-    expect(updatedRec?.id).toBe(ctx.createdRecordId)
-
-    // Delete
-    const delete_record = buildWriteHandler('delete_record')
-    const del = await delete_record({ baseId: ctx.baseId, tableId: ctx.tableId, recordId: ctx.createdRecordId })
-    const deletedRec = del?.records?.[0] || del
-    expect(deletedRec?.deleted === true || deletedRec?.id === ctx.createdRecordId).toBe(true)
-  }, 90000)
-})
-
-// Admin operations are not available on standard plans; omitted.

package/integrations/airtable/credentials.json

@@ -1,26 +0,0 @@
-{
-  "variants": {
-    "personal_access_token": {
-      "label": "Personal Access Token",
-      "schema": {
-        "type": "object",
-        "properties": {
-          "token": {
-            "type": "string",
-            "title": "Personal Access Token",
-            "description": "Airtable personal access token."
-          }
-        },
-        "required": ["token"],
-        "additionalProperties": false
-      },
-      "injection": {
-        "headers": {
-          "Authorization": "Bearer {{token}}"
-        }
-      },
-      "healthCheck": { "path": "/meta/whoami" }
-    }
-  },
-  "default": "personal_access_token"
-}

package/integrations/airtable/credentials_hint.md

@@ -1,4 +0,0 @@
-Create an Airtable personal access token and paste it here.
-
-You can generate one in Airtable account settings under developer tools / personal access tokens.
-

package/integrations/airtable/handlers/create_record.js

@@ -1,12 +0,0 @@
-async (input) => {
-  const path = `/${input.baseId}/${input.tableId}`
-  const body = {
-    records: [
-      { fields: input.fields },
-    ],
-    typecast: !!input.typecast,
-  }
-  const res = await integration.fetch(path, { method: 'POST', body })
-  const data = await res.json()
-  return data
-}

package/integrations/airtable/handlers/delete_record.js

@@ -1,7 +0,0 @@
-async (input) => {
-  const path = `/${input.baseId}/${input.tableId}`
-  const params = new URLSearchParams()
-  params.set('records[]', input.recordId)
-  const res = await integration.fetch(`${path}?${params.toString()}`, { method: 'DELETE' })
-  return await res.json()
-}

package/integrations/airtable/handlers/get_record.js

@@ -1,4 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/${input.baseId}/${input.tableId}/${input.recordId}`)
-  return await res.json()
-}

package/integrations/airtable/handlers/get_table_schema.js

@@ -1,6 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
-  const data = await res.json()
-  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
-  return table || null
-}

package/integrations/airtable/handlers/list_bases.js

@@ -1,4 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/meta/bases`)
-  return await res.json()
-}

package/integrations/airtable/handlers/list_records.js

@@ -1,25 +0,0 @@
-async (input) => {
-  const params = new URLSearchParams()
-  if (input.view)
-    params.set('view', input.view)
-  if (input.maxRecords)
-    params.set('maxRecords', String(input.maxRecords))
-  if (input.pageSize)
-    params.set('pageSize', String(input.pageSize))
-  if (input.filterByFormula)
-    params.set('filterByFormula', input.filterByFormula)
-  if (input.sort && Array.isArray(input.sort)) {
-    input.sort.forEach((s, i) => {
-      if (s && typeof s === 'object') {
-        if (s.field)
-          params.set(`sort[${i}][field]`, String(s.field))
-        if (s.direction)
-          params.set(`sort[${i}][direction]`, String(s.direction))
-      }
-    })
-  }
-  const qs = params.toString()
-  const path = `/${input.baseId}/${input.tableId}${qs ? `?${qs}` : ''}`
-  const res = await integration.fetch(path)
-  return await res.json()
-}

package/integrations/airtable/handlers/list_table_fields.js

@@ -1,6 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
-  const data = await res.json()
-  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
-  return table?.fields || []
-}

package/integrations/airtable/handlers/list_tables.js

@@ -1,4 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
-  return await res.json()
-}

package/integrations/airtable/handlers/list_views.js

@@ -1,6 +0,0 @@
-async (input) => {
-  const res = await integration.fetch(`/meta/bases/${input.baseId}/tables`)
-  const data = await res.json()
-  const table = (data?.tables || data)?.find?.(t => t.id === input.tableId || t.name === input.tableId)
-  return table?.views || []
-}

package/integrations/airtable/handlers/search_records.js

@@ -1,6 +0,0 @@
-async (input) => {
-  const formula = `{${input.field}} = "${input.value}"`
-  const params = new URLSearchParams({ filterByFormula: formula })
-  const res = await integration.fetch(`/${input.baseId}/${input.tableId}?${params.toString()}`)
-  return await res.json()
-}

package/integrations/airtable/handlers/update_record.js

@@ -1,11 +0,0 @@
-async (input) => {
-  const path = `/${input.baseId}/${input.tableId}`
-  const body = {
-    records: [
-      { id: input.recordId, fields: input.fields },
-    ],
-    typecast: !!input.typecast,
-  }
-  const res = await integration.fetch(path, { method: 'PATCH', body })
-  return await res.json()
-}