@commandable/integration-data 0.0.1

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

@@ -0,0 +1,137 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE Airtable integration tests using managed OAuth
+// Required env vars:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - AIRTABLE_TEST_CONNECTION_ID (managed OAuth connection for provider 'airtable')
+
+interface Ctx {
+  baseId?: string
+  tableId?: string
+  recordId?: 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(
+  'COMMANDABLE_MANAGED_OAUTH_BASE_URL',
+  'COMMANDABLE_MANAGED_OAUTH_SECRET_KEY',
+  'AIRTABLE_TEST_CONNECTION_ID',
+)
+  ? describe
+  : describe.skip
+
+suite('airtable read handlers (live)', () => {
+  const ctx: Ctx = {}
+  let buildHandler: (name: string) => ((input: any) => Promise<any>)
+
+  beforeAll(async () => {
+    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, AIRTABLE_TEST_CONNECTION_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-airtable', type: 'airtable', label: 'Airtable', connectionId: AIRTABLE_TEST_CONNECTION_ID } 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>
+    }
+
+    // Discover base -> table -> record for tests
+    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
+
+      if (ctx.tableId) {
+        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)
+
+  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

@@ -0,0 +1,35 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { loadIntegrationManifest } from '../../../src/integrations/dataLoader.js'
+
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+describe('airtable static usage parity', () => {
+  it('every manifest tool is referenced in tests via build*(name)', () => {
+    const manifest = loadIntegrationManifest('airtable')!
+    const toolNames = (manifest.tools as any[]).map(t => t.name)
+
+    const testsDir = fileURLToPath(new URL('.', import.meta.url))
+    expect(existsSync(testsDir)).toBe(true)
+    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) {
+      // Matches buildRead('x'), buildWrite('x'), buildAdmin('x'), buildHandler('x'), buildReadHandler('x'), buildWriteHandler('x')
+      const nameRe = new RegExp(`build(?:Read|Write|Admin)?(?:Handler)?\\(\\s*['\"\`]${escapeRegExp(name)}['\"\`]\\s*\\)`, 'm')
+      const found = fileContents.some(src => nameRe.test(src))
+      if (!found)
+        missing.push(name)
+    }
+
+    expect(missing, `Missing handler usages in tests: ${missing.join(', ')}`).toEqual([])
+  })
+})

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

@@ -0,0 +1,113 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE Airtable write tests using managed OAuth
+// Required env vars for write tests:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - AIRTABLE_TEST_CONNECTION_ID (managed OAuth connection for provider 'airtable')
+// 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(
+  'COMMANDABLE_MANAGED_OAUTH_BASE_URL',
+  'COMMANDABLE_MANAGED_OAUTH_SECRET_KEY',
+  'AIRTABLE_TEST_CONNECTION_ID',
+)
+  ? 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 { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, AIRTABLE_TEST_CONNECTION_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-airtable', type: 'airtable', label: 'Airtable', connectionId: AIRTABLE_TEST_CONNECTION_ID } 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

@@ -0,0 +1,20 @@
+{
+  "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}}"
+    }
+  }
+}
+

package/integrations/airtable/credentials_hint.md

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,6 @@
+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

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

package/integrations/airtable/handlers/list_records.js

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,6 @@
+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

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

package/integrations/airtable/handlers/list_views.js

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,11 @@
+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()
+}

package/integrations/airtable/manifest.json

@@ -0,0 +1,83 @@
+{
+  "name": "airtable",
+  "version": "0.1.0",
+  "tools": [
+    {
+      "name": "list_bases",
+      "description": "List bases available to the authenticated user.",
+      "inputSchema": "schemas/empty.json",
+      "handler": "handlers/list_bases.js",
+      "scope": "read"
+    },
+    {
+      "name": "list_tables",
+      "description": "List tables in a base (metadata).",
+      "inputSchema": "schemas/id_base.json",
+      "handler": "handlers/list_tables.js",
+      "scope": "read"
+    },
+    {
+      "name": "get_table_schema",
+      "description": "Fetch a table's schema (fields, views) by tableId via metadata.",
+      "inputSchema": "schemas/id_base_table.json",
+      "handler": "handlers/get_table_schema.js",
+      "scope": "read"
+    },
+    {
+      "name": "list_table_fields",
+      "description": "List fields for a table (metadata).",
+      "inputSchema": "schemas/id_base_table.json",
+      "handler": "handlers/list_table_fields.js",
+      "scope": "read"
+    },
+    {
+      "name": "list_views",
+      "description": "List views for a table (metadata).",
+      "inputSchema": "schemas/id_base_table.json",
+      "handler": "handlers/list_views.js",
+      "scope": "read"
+    },
+    {
+      "name": "list_records",
+      "description": "List records from a table with optional filters.",
+      "inputSchema": "schemas/list_records.json",
+      "handler": "handlers/list_records.js",
+      "scope": "read"
+    },
+    {
+      "name": "get_record",
+      "description": "Fetch a single record by recordId.",
+      "inputSchema": "schemas/get_record.json",
+      "handler": "handlers/get_record.js",
+      "scope": "read"
+    },
+    {
+      "name": "search_records",
+      "description": "Search records in a table using a field and value (filterByFormula).",
+      "inputSchema": "schemas/search_records.json",
+      "handler": "handlers/search_records.js",
+      "scope": "read"
+    },
+    {
+      "name": "create_record",
+      "description": "Create a record in a table.",
+      "inputSchema": "schemas/create_record.json",
+      "handler": "handlers/create_record.js",
+      "scope": "write"
+    },
+    {
+      "name": "update_record",
+      "description": "Update a record in a table.",
+      "inputSchema": "schemas/update_record.json",
+      "handler": "handlers/update_record.js",
+      "scope": "write"
+    },
+    {
+      "name": "delete_record",
+      "description": "Delete a record from a table.",
+      "inputSchema": "schemas/delete_record.json",
+      "handler": "handlers/delete_record.js",
+      "scope": "write"
+    }
+  ]
+}

package/integrations/airtable/schemas/create_record.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "baseId": { "type": "string", "description": "Airtable base ID" },
+    "tableId": { "type": "string", "description": "Airtable table ID or name" },
+    "fields": { "type": "object", "description": "Field values for the new record" },
+    "typecast": { "type": "boolean", "description": "Coerce values to field types" }
+  },
+  "required": ["baseId", "tableId", "fields"],
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/delete_record.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "baseId": { "type": "string" },
+    "tableId": { "type": "string" },
+    "recordId": { "type": "string" }
+  },
+  "required": ["baseId", "tableId", "recordId"],
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/empty.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/get_record.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["baseId", "tableId", "recordId"],
+  "properties": {
+    "baseId": { "type": "string" },
+    "tableId": { "type": "string" },
+    "recordId": { "type": "string" }
+  },
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/id_base.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["baseId"],
+  "properties": {
+    "baseId": { "type": "string", "description": "Airtable base ID" }
+  },
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/id_base_table.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["baseId", "tableId"],
+  "properties": {
+    "baseId": { "type": "string", "description": "Airtable base ID" },
+    "tableId": { "type": "string", "description": "Airtable table ID (tbl...)" }
+  },
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/list_records.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["baseId", "tableId"],
+  "properties": {
+    "baseId": { "type": "string" },
+    "tableId": { "type": "string" },
+    "view": { "type": "string", "description": "Optional view name or ID" },
+    "maxRecords": { "type": "integer", "minimum": 1 },
+    "pageSize": { "type": "integer", "minimum": 1 },
+    "filterByFormula": { "type": "string" },
+    "sort": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["field"],
+        "properties": {
+          "field": { "type": "string" },
+          "direction": { "type": "string", "enum": ["asc", "desc"] }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/search_records.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["baseId", "tableId", "field", "value"],
+  "properties": {
+    "baseId": { "type": "string" },
+    "tableId": { "type": "string" },
+    "field": { "type": "string", "description": "Field name to match" },
+    "value": { "type": "string", "description": "Value to search for" }
+  },
+  "additionalProperties": false
+}

package/integrations/airtable/schemas/update_record.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "baseId": { "type": "string" },
+    "tableId": { "type": "string" },
+    "recordId": { "type": "string" },
+    "fields": { "type": "object" },
+    "typecast": { "type": "boolean" }
+  },
+  "required": ["baseId", "tableId", "recordId", "fields"],
+  "additionalProperties": false
+}