@commandable/integration-data 0.0.1

package/integrations/google-sheet/__tests__/get_handlers.test.ts

@@ -0,0 +1,129 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE Google Sheets read tests using managed OAuth
+// Required env vars:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - GSHEETS_TEST_CONNECTION_ID (managed OAuth connection for provider 'google-sheet')
+// - GSHEETS_TEST_SPREADSHEET_ID (an accessible spreadsheet ID)
+
+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',
+  'GSHEETS_TEST_CONNECTION_ID',
+)
+  ? describe
+  : describe.skip
+
+suite('google-sheet read handlers (live)', () => {
+  let buildReadHandler: (name: string) => ((input: any) => Promise<any>)
+  let sheetTitle: string | undefined
+
+  beforeAll(async () => {
+    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, GSHEETS_TEST_CONNECTION_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-gsheets', type: 'google-sheet', label: 'Google Sheets', connectionId: GSHEETS_TEST_CONNECTION_ID } as any
+
+    const tools = loadIntegrationTools('google-sheet')
+    expect(tools).toBeTruthy()
+
+    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>
+    }
+
+    // Try to detect a default sheet title
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (spreadsheetId) {
+      try {
+        const get_spreadsheet = buildReadHandler('get_spreadsheet')
+        const meta = await get_spreadsheet({ spreadsheetId })
+        sheetTitle = meta?.sheets?.[0]?.properties?.title
+      }
+      catch {}
+    }
+  }, 60000)
+
+  it('get_spreadsheet returns metadata', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('get_spreadsheet')
+    const result = await handler({ spreadsheetId })
+    expect(result?.spreadsheetId || result?.sheets).toBeTruthy()
+  }, 30000)
+
+  it('get_values returns a value range', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('get_values')
+    const range = sheetTitle ? `${sheetTitle}!A1:B5` : 'A1:B5'
+    const result = await handler({ spreadsheetId, range })
+    expect(result?.range || result?.values).toBeTruthy()
+  }, 30000)
+
+  it('batch_get_values returns multiple ranges', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('batch_get_values')
+    const aTitle = sheetTitle || 'Sheet1'
+    const result = await handler({ spreadsheetId, ranges: [`${aTitle}!A1:A3`, `${aTitle}!B1:B3`] })
+    expect(Array.isArray(result?.valueRanges)).toBe(true)
+  }, 30000)
+
+  it('get_spreadsheet_by_data_filter returns metadata', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('get_spreadsheet_by_data_filter')
+    const aTitle = sheetTitle || 'Sheet1'
+    const result = await handler({ spreadsheetId, dataFilters: [{ a1Range: `${aTitle}!A1:A1` }] })
+    expect(result?.spreadsheetId || result?.sheets).toBeTruthy()
+  }, 30000)
+
+  it('get_values_by_data_filter returns values', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('get_values_by_data_filter')
+    const aTitle = sheetTitle || 'Sheet1'
+    const result = await handler({ spreadsheetId, dataFilters: [{ a1Range: `${aTitle}!A1:B2` }] })
+    expect(Array.isArray(result?.valueRanges)).toBe(true)
+  }, 30000)
+
+  it('search_developer_metadata returns results or empty', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const handler = buildReadHandler('search_developer_metadata')
+    const result = await handler({ spreadsheetId, dataFilters: [{ developerMetadataLookup: { visibility: 'DOCUMENT' } }] })
+    expect(result !== undefined).toBe(true)
+  }, 30000)
+
+  it('get_developer_metadata retrieves by id when available', async () => {
+    const spreadsheetId = env.GSHEETS_TEST_SPREADSHEET_ID
+    if (!spreadsheetId)
+      return expect(true).toBe(true)
+    const search = buildReadHandler('search_developer_metadata')
+    const list = await search({ spreadsheetId, dataFilters: [{ developerMetadataLookup: { visibility: 'DOCUMENT' } }] })
+    const first = list?.matchedDeveloperMetadata?.[0]?.developerMetadata || list?.developerMetadata?.[0]
+    if (!first?.metadataId)
+      return expect(true).toBe(true)
+    const getdm = buildReadHandler('get_developer_metadata')
+    const got = await getdm({ spreadsheetId, metadataId: first.metadataId })
+    expect(got?.metadataId).toBe(first.metadataId)
+  }, 30000)
+})

package/integrations/google-sheet/__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('google-sheet static usage parity', () => {
+  it('every manifest tool is referenced in tests via build*(name)', () => {
+    const manifest = loadIntegrationManifest('google-sheet')!
+    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/google-sheet/__tests__/write_handlers.test.ts

@@ -0,0 +1,171 @@
+import { beforeAll, describe, expect, it } from 'vitest'
+import { IntegrationProxy } from '../../../src/integrations/proxy.js'
+import { loadIntegrationTools } from '../../../src/integrations/dataLoader.js'
+
+// LIVE Google Sheets write tests using managed OAuth
+// Required env vars:
+// - COMMANDABLE_MANAGED_OAUTH_BASE_URL
+// - COMMANDABLE_MANAGED_OAUTH_SECRET_KEY
+// - GSHEETS_TEST_CONNECTION_ID (managed OAuth connection for provider 'google-sheet')
+// - GSHEETS_TEST_SPREADSHEET_ID (target spreadsheet ID with write access)
+
+interface Ctx {
+  spreadsheetId?: 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',
+  'GSHEETS_TEST_CONNECTION_ID',
+  'GSHEETS_TEST_SPREADSHEET_ID',
+)
+  ? describe
+  : describe.skip
+
+suite('google-sheet write handlers (live)', () => {
+  const ctx: Ctx = {}
+  let buildWriteHandler: (name: string) => ((input: any) => Promise<any>)
+  let sheetTitle: string | undefined
+
+  beforeAll(async () => {
+    const { COMMANDABLE_MANAGED_OAUTH_BASE_URL, COMMANDABLE_MANAGED_OAUTH_SECRET_KEY, GSHEETS_TEST_CONNECTION_ID, GSHEETS_TEST_SPREADSHEET_ID } = env
+
+    const proxy = new IntegrationProxy({
+      managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+      managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+    })
+    const integrationNode = { id: 'node-gsheets', type: 'google-sheet', label: 'Google Sheets', connectionId: GSHEETS_TEST_CONNECTION_ID } as any
+
+    const tools = loadIntegrationTools('google-sheet')
+    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>
+    }
+
+    ctx.spreadsheetId = GSHEETS_TEST_SPREADSHEET_ID
+
+    // Try to detect a default sheet title
+    if (ctx.spreadsheetId) {
+      const proxy2 = new IntegrationProxy({
+        managedOAuthBaseUrl: COMMANDABLE_MANAGED_OAUTH_BASE_URL,
+        managedOAuthSecretKey: COMMANDABLE_MANAGED_OAUTH_SECRET_KEY,
+      })
+      const node2 = { id: 'node-gsheets', type: 'google-sheet', label: 'Google Sheets', connectionId: GSHEETS_TEST_CONNECTION_ID } as any
+      const tools2 = loadIntegrationTools('google-sheet')!
+      const tool = tools2.read.find(t => t.name === 'get_spreadsheet')!
+      const build = new Function('integration', `return (${tool.handlerCode});`)
+      const integration = { fetch: (path: string, init?: RequestInit) => proxy2.call(node2, path, init) }
+      try {
+        const get_spreadsheet = build(integration) as (input: any) => Promise<any>
+        const meta = await get_spreadsheet({ spreadsheetId: ctx.spreadsheetId })
+        sheetTitle = meta?.sheets?.[0]?.properties?.title
+      }
+      catch {}
+    }
+  }, 60000)
+
+  it('append_values appends then clear_values clears', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+
+    const append_values = buildWriteHandler('append_values')
+    const aTitle = sheetTitle || 'Sheet1'
+    const appendRes = await append_values({ spreadsheetId: ctx.spreadsheetId, range: `${aTitle}!A1`, values: [[`CmdTest ${Date.now()}`]], valueInputOption: 'USER_ENTERED' })
+    expect(appendRes?.updates || appendRes?.tableRange || appendRes?.spreadsheetId).toBeTruthy()
+
+    const clear_values = buildWriteHandler('clear_values')
+    const clearRes = await clear_values({ spreadsheetId: ctx.spreadsheetId, range: `${aTitle}!A1:A10` })
+    expect(clearRes?.clearedRange || clearRes?.spreadsheetId).toBeTruthy()
+  }, 60000)
+
+  it('update_values updates a range', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const update_values = buildWriteHandler('update_values')
+    const res = await update_values({ spreadsheetId: ctx.spreadsheetId, range: `${aTitle}!B1:B1`, values: [[`CmdTestU ${Date.now()}`]], valueInputOption: 'USER_ENTERED' })
+    expect(res?.updatedRange || res?.spreadsheetId).toBeTruthy()
+  }, 60000)
+
+  it('batch_update_values updates multiple ranges', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const batch_update_values = buildWriteHandler('batch_update_values')
+    const res = await batch_update_values({ spreadsheetId: ctx.spreadsheetId, data: [
+      { range: `${aTitle}!C1:C1`, values: [[`CmdTestB1 ${Date.now()}`]] },
+      { range: `${aTitle}!C2:C2`, values: [[`CmdTestB2 ${Date.now()}`]] },
+    ], valueInputOption: 'USER_ENTERED', includeValuesInResponse: true })
+    expect(res?.totalUpdatedCells >= 0 || res?.spreadsheetId).toBeTruthy()
+  }, 60000)
+
+  it('batch_update_values_by_data_filter updates via filters', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const batch_update_values_by_data_filter = buildWriteHandler('batch_update_values_by_data_filter')
+    const res = await batch_update_values_by_data_filter({ spreadsheetId: ctx.spreadsheetId, data: [
+      { dataFilter: { a1Range: `${aTitle}!D1:D1` }, values: [[`CmdTestDF ${Date.now()}`]] },
+    ], valueInputOption: 'USER_ENTERED' })
+    expect(res?.totalUpdatedCells >= 0 || res?.spreadsheetId).toBeTruthy()
+  }, 60000)
+
+  it('batch_clear_values clears multiple ranges', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const batch_clear_values = buildWriteHandler('batch_clear_values')
+    const res = await batch_clear_values({ spreadsheetId: ctx.spreadsheetId, ranges: [`${aTitle}!A1:A2`, `${aTitle}!B1:B2`] })
+    expect(Boolean(res?.spreadsheetId) || Array.isArray(res?.clearedRanges)).toBe(true)
+  }, 60000)
+
+  it('batch_clear_values_by_data_filter clears via filters', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const batch_clear_values_by_data_filter = buildWriteHandler('batch_clear_values_by_data_filter')
+    const res = await batch_clear_values_by_data_filter({ spreadsheetId: ctx.spreadsheetId, dataFilters: [{ a1Range: `${aTitle}!E1:E2` }] })
+    expect(Boolean(res?.spreadsheetId) || Array.isArray(res?.clearedRanges)).toBe(true)
+  }, 60000)
+
+  it('batch_update handles a trivial request (no-op findReplace)', async () => {
+    if (!ctx.spreadsheetId)
+      return expect(true).toBe(true)
+    const aTitle = sheetTitle || 'Sheet1'
+    const batch_update = buildWriteHandler('batch_update')
+    const res = await batch_update({ spreadsheetId: ctx.spreadsheetId, requests: [
+      { findReplace: { find: '___unlikely___', replacement: '___unlikely___', matchCase: true, searchByRegex: false, includeFormulas: false, range: { sheetId: 0 } } },
+    ], includeSpreadsheetInResponse: false })
+    expect(res?.spreadsheetId).toBeTruthy()
+  }, 60000)
+
+  it('copy_to_spreadsheet copies a sheet when destination provided', async () => {
+    if (!ctx.spreadsheetId || !env.GSHEETS_TEST_DEST_SPREADSHEET_ID)
+      return expect(true).toBe(true)
+    const copy_to_spreadsheet = buildWriteHandler('copy_to_spreadsheet')
+    // Attempt to copy sheet with id 0 (typical for first sheet). If it fails, skip.
+    try {
+      const res = await copy_to_spreadsheet({ spreadsheetId: ctx.spreadsheetId, sheetId: 0, destinationSpreadsheetId: env.GSHEETS_TEST_DEST_SPREADSHEET_ID })
+      expect(res?.sheetId !== undefined || res?.spreadsheetId).toBeTruthy()
+    }
+    catch {
+      expect(true).toBe(true)
+    }
+  }, 60000)
+
+  it('create_spreadsheet creates a spreadsheet when allowed', async () => {
+    if (!env.GSHEETS_ALLOW_CREATE)
+      return expect(true).toBe(true)
+    const create_spreadsheet = buildWriteHandler('create_spreadsheet')
+    const res = await create_spreadsheet({ properties: { title: `CmdTest ${Date.now()}` } })
+    expect(res?.spreadsheetId).toBeTruthy()
+    // Note: No delete here to avoid Drive scope; test leaves an artifact when enabled.
+  }, 60000)
+})

package/integrations/google-sheet/credentials.json

@@ -0,0 +1,36 @@
+{
+  "schema": {
+    "type": "object",
+    "properties": {
+      "token": {
+        "type": "string",
+        "title": "OAuth Access Token (optional)",
+        "description": "Google OAuth access token to use as a Bearer token (typically short-lived)."
+      },
+      "serviceAccountJson": {
+        "type": "string",
+        "title": "Service Account JSON (recommended)",
+        "description": "Full service account key JSON (contents of the downloaded JSON file)."
+      },
+      "subject": {
+        "type": "string",
+        "title": "Subject / impersonated user (optional)",
+        "description": "Optional user email to impersonate when using Google Workspace domain-wide delegation."
+      },
+      "scopes": {
+        "type": "array",
+        "title": "OAuth scopes (optional)",
+        "description": "Optional override for OAuth scopes.",
+        "items": { "type": "string" }
+      }
+    },
+    "required": [],
+    "additionalProperties": false
+  },
+  "injection": {
+    "headers": {
+      "Authorization": "Bearer {{token}}"
+    }
+  }
+}
+

package/integrations/google-sheet/credentials_hint.md

@@ -0,0 +1,9 @@
+Recommended: use a Google service account.
+
+- Create a service account in Google Cloud
+- Download a JSON key
+- Paste the JSON into `serviceAccountJson` (or use `env:GOOGLE_SERVICE_ACCOUNT_JSON`)
+- Share your test spreadsheet with the service account `client_email`
+
+You can also paste a short-lived OAuth access token into `token`, but it will expire.
+

package/integrations/google-sheet/handlers/append_values.js

@@ -0,0 +1,18 @@
+async (input) => {
+  const { spreadsheetId, range, values, valueInputOption, insertDataOption, includeValuesInResponse, responseValueRenderOption, responseDateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (valueInputOption)
+    params.set('valueInputOption', valueInputOption)
+  if (insertDataOption)
+    params.set('insertDataOption', insertDataOption)
+  if (includeValuesInResponse !== undefined)
+    params.set('includeValuesInResponse', String(includeValuesInResponse))
+  if (responseValueRenderOption)
+    params.set('responseValueRenderOption', responseValueRenderOption)
+  if (responseDateTimeRenderOption)
+    params.set('responseDateTimeRenderOption', responseDateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}:append${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { values } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_clear_values.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { spreadsheetId, ranges } = input
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchClear`
+  const res = await integration.fetch(path, { method: 'POST', body: { ranges } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_clear_values_by_data_filter.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { spreadsheetId, dataFilters } = input
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchClearByDataFilter`
+  const res = await integration.fetch(path, { method: 'POST', body: { dataFilters } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_get_values.js

@@ -0,0 +1,16 @@
+async (input) => {
+  const { spreadsheetId, ranges, majorDimension, valueRenderOption, dateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (Array.isArray(ranges))
+    ranges.forEach(r => params.append('ranges', String(r)))
+  if (majorDimension)
+    params.set('majorDimension', majorDimension)
+  if (valueRenderOption)
+    params.set('valueRenderOption', valueRenderOption)
+  if (dateTimeRenderOption)
+    params.set('dateTimeRenderOption', dateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchGet${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_update.js

@@ -0,0 +1,14 @@
+async (input) => {
+  const { spreadsheetId, requests, includeSpreadsheetInResponse, responseRanges, responseIncludeGridData } = input
+  const params = new URLSearchParams()
+  if (includeSpreadsheetInResponse !== undefined)
+    params.set('includeSpreadsheetInResponse', String(includeSpreadsheetInResponse))
+  if (Array.isArray(responseRanges))
+    responseRanges.forEach(r => params.append('responseRanges', String(r)))
+  if (responseIncludeGridData !== undefined)
+    params.set('responseIncludeGridData', String(responseIncludeGridData))
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}:batchUpdate${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { requests } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_update_values.js

@@ -0,0 +1,16 @@
+async (input) => {
+  const { spreadsheetId, data, valueInputOption, includeValuesInResponse, responseValueRenderOption, responseDateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (valueInputOption)
+    params.set('valueInputOption', valueInputOption)
+  if (includeValuesInResponse !== undefined)
+    params.set('includeValuesInResponse', String(includeValuesInResponse))
+  if (responseValueRenderOption)
+    params.set('responseValueRenderOption', responseValueRenderOption)
+  if (responseDateTimeRenderOption)
+    params.set('responseDateTimeRenderOption', responseDateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchUpdate${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { data } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/batch_update_values_by_data_filter.js

@@ -0,0 +1,16 @@
+async (input) => {
+  const { spreadsheetId, data, valueInputOption, includeValuesInResponse, responseValueRenderOption, responseDateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (valueInputOption)
+    params.set('valueInputOption', valueInputOption)
+  if (includeValuesInResponse !== undefined)
+    params.set('includeValuesInResponse', String(includeValuesInResponse))
+  if (responseValueRenderOption)
+    params.set('responseValueRenderOption', responseValueRenderOption)
+  if (responseDateTimeRenderOption)
+    params.set('responseDateTimeRenderOption', responseDateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchUpdateByDataFilter${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { data } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/clear_values.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { spreadsheetId, range } = input
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}:clear`
+  const res = await integration.fetch(path, { method: 'POST', body: {} })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/copy_to_spreadsheet.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { spreadsheetId, sheetId, destinationSpreadsheetId } = input
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/sheets/${encodeURIComponent(sheetId)}:copyTo`
+  const res = await integration.fetch(path, { method: 'POST', body: { destinationSpreadsheetId } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/create_spreadsheet.js

@@ -0,0 +1,5 @@
+async (input) => {
+  const path = `/spreadsheets`
+  const res = await integration.fetch(path, { method: 'POST', body: input })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/get_developer_metadata.js

@@ -0,0 +1,6 @@
+async (input) => {
+  const { spreadsheetId, metadataId } = input
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/developerMetadata/${encodeURIComponent(metadataId)}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-sheet/handlers/get_spreadsheet.js

@@ -0,0 +1,12 @@
+async (input) => {
+  const { spreadsheetId, includeGridData, ranges } = input
+  const params = new URLSearchParams()
+  if (includeGridData !== undefined)
+    params.set('includeGridData', String(includeGridData))
+  if (Array.isArray(ranges))
+    ranges.forEach(r => params.append('ranges', String(r)))
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-sheet/handlers/get_spreadsheet_by_data_filter.js

@@ -0,0 +1,10 @@
+async (input) => {
+  const { spreadsheetId, dataFilters, includeGridData } = input
+  const params = new URLSearchParams()
+  if (includeGridData !== undefined)
+    params.set('includeGridData', String(includeGridData))
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}:getByDataFilter${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { dataFilters } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/get_values.js

@@ -0,0 +1,14 @@
+async (input) => {
+  const { spreadsheetId, range, majorDimension, valueRenderOption, dateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (majorDimension)
+    params.set('majorDimension', majorDimension)
+  if (valueRenderOption)
+    params.set('valueRenderOption', valueRenderOption)
+  if (dateTimeRenderOption)
+    params.set('dateTimeRenderOption', dateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path)
+  return await res.json()
+}

package/integrations/google-sheet/handlers/get_values_by_data_filter.js

@@ -0,0 +1,14 @@
+async (input) => {
+  const { spreadsheetId, dataFilters, majorDimension, valueRenderOption, dateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (majorDimension)
+    params.set('majorDimension', majorDimension)
+  if (valueRenderOption)
+    params.set('valueRenderOption', valueRenderOption)
+  if (dateTimeRenderOption)
+    params.set('dateTimeRenderOption', dateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values:batchGetByDataFilter${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'POST', body: { dataFilters } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/search_developer_metadata.js

@@ -0,0 +1,7 @@
+async (input) => {
+  const { spreadsheetId, dataFilters } = input
+  // Correct endpoint per Sheets API: /spreadsheets/{spreadsheetId}/developerMetadata:search
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/developerMetadata:search`
+  const res = await integration.fetch(path, { method: 'POST', body: { dataFilters } })
+  return await res.json()
+}

package/integrations/google-sheet/handlers/update_values.js

@@ -0,0 +1,16 @@
+async (input) => {
+  const { spreadsheetId, range, values, valueInputOption, includeValuesInResponse, responseValueRenderOption, responseDateTimeRenderOption } = input
+  const params = new URLSearchParams()
+  if (valueInputOption)
+    params.set('valueInputOption', valueInputOption)
+  if (includeValuesInResponse !== undefined)
+    params.set('includeValuesInResponse', String(includeValuesInResponse))
+  if (responseValueRenderOption)
+    params.set('responseValueRenderOption', responseValueRenderOption)
+  if (responseDateTimeRenderOption)
+    params.set('responseDateTimeRenderOption', responseDateTimeRenderOption)
+  const qs = params.toString()
+  const path = `/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}${qs ? `?${qs}` : ''}`
+  const res = await integration.fetch(path, { method: 'PUT', body: { values } })
+  return await res.json()
+}