feat(athena): complete SQL-workload coverage with prepared statements, catalogs, and workgroups (#7614)

* feat(athena): complete SQL-workload coverage with prepared statements, catalogs, and workgroups

Adds 15 tools so the Athena block covers the full SQL workload surface: prepared statements (create/get/batch get/update/list/delete), get query runtime statistics, batch get and update named queries, list/get data catalogs, get database, get table metadata, and list/get workgroups. Start query now accepts execution parameters and result reuse configuration. Contracts share one connection schema with region validation, and list databases now returns database parameters.

Claude-Session: https://claude.ai/code/session_01AtPwvDwhkhed2MwcZudrPN

* fix(athena): keep zero-minute result reuse age, enforce name patterns, declare table parameters output

Claude-Session: https://claude.ai/code/session_01AtPwvDwhkhed2MwcZudrPN

Author: waleedlatif1

apps/docs/content/docs/integrations/athena.mdx

@@ -0,0 +1,48 @@
+import { z } from 'zod'
+import {
+  athenaConnectionSchema,
+  athenaNamedQuerySchema,
+} from '@/lib/api/contracts/tools/aws/athena-shared'
+import type {
+  ContractBody,
+  ContractBodyInput,
+  ContractJsonResponse,
+} from '@/lib/api/contracts/types'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const BatchGetNamedQuerySchema = athenaConnectionSchema.extend({
+  namedQueryIds: z
+    .array(z.string().trim().min(1))
+    .min(1, 'At least one named query ID is required')
+    .max(50, 'A maximum of 50 named query IDs can be requested at once'),
+})
+
+const BatchGetNamedQueryResponseSchema = z.object({
+  success: z.literal(true),
+  output: z.object({
+    namedQueries: z.array(athenaNamedQuerySchema),
+    unprocessedNamedQueryIds: z.array(
+      z.object({
+        namedQueryId: z.string().nullable(),
+        errorCode: z.string().nullable(),
+        errorMessage: z.string().nullable(),
+      })
+    ),
+  }),
+})
+
+export const awsAthenaBatchGetNamedQueryContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/tools/athena/batch-get-named-query',
+  body: BatchGetNamedQuerySchema,
+  response: { mode: 'json', schema: BatchGetNamedQueryResponseSchema },
+})
+export type AwsAthenaBatchGetNamedQueryRequest = ContractBodyInput<
+  typeof awsAthenaBatchGetNamedQueryContract
+>
+export type AwsAthenaBatchGetNamedQueryBody = ContractBody<
+  typeof awsAthenaBatchGetNamedQueryContract
+>
+export type AwsAthenaBatchGetNamedQueryResponse = ContractJsonResponse<
+  typeof awsAthenaBatchGetNamedQueryContract
+>

apps/sim/blocks/blocks/athena.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod'
+import {
+  athenaConnectionSchema,
+  athenaPreparedStatementSchema,
+  athenaStatementNameSchema,
+  athenaWorkGroupSchema,
+} from '@/lib/api/contracts/tools/aws/athena-shared'
+import type {
+  ContractBody,
+  ContractBodyInput,
+  ContractJsonResponse,
+} from '@/lib/api/contracts/types'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const BatchGetPreparedStatementSchema = athenaConnectionSchema.extend({
+  preparedStatementNames: z
+    .array(athenaStatementNameSchema)
+    .min(1, 'At least one prepared statement name is required')
+    .max(256, 'A maximum of 256 prepared statement names can be requested at once'),
+  workGroup: athenaWorkGroupSchema,
+})
+
+const BatchGetPreparedStatementResponseSchema = z.object({
+  success: z.literal(true),
+  output: z.object({
+    preparedStatements: z.array(athenaPreparedStatementSchema),
+    unprocessedPreparedStatementNames: z.array(
+      z.object({
+        statementName: z.string().nullable(),
+        errorCode: z.string().nullable(),
+        errorMessage: z.string().nullable(),
+      })
+    ),
+  }),
+})
+
+export const awsAthenaBatchGetPreparedStatementContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/tools/athena/batch-get-prepared-statement',
+  body: BatchGetPreparedStatementSchema,
+  response: { mode: 'json', schema: BatchGetPreparedStatementResponseSchema },
+})
+export type AwsAthenaBatchGetPreparedStatementRequest = ContractBodyInput<
+  typeof awsAthenaBatchGetPreparedStatementContract
+>
+export type AwsAthenaBatchGetPreparedStatementBody = ContractBody<
+  typeof awsAthenaBatchGetPreparedStatementContract
+>
+export type AwsAthenaBatchGetPreparedStatementResponse = ContractJsonResponse<
+  typeof awsAthenaBatchGetPreparedStatementContract
+>

apps/sim/lib/api/contracts/tools/aws/athena-batch-get-named-query.ts

@@ -1,21 +1,13 @@
 import { z } from 'zod'
+import { athenaConnectionSchema } from '@/lib/api/contracts/tools/aws/athena-shared'
 import type {
   ContractBody,
   ContractBodyInput,
   ContractJsonResponse,
 } from '@/lib/api/contracts/types'
 import { defineRouteContract } from '@/lib/api/contracts/types'
-import { validateAwsRegion } from '@/lib/core/security/input-validation'
 
-const BatchGetQueryExecutionSchema = z.object({
-  region: z
-    .string()
-    .min(1, 'AWS region is required')
-    .refine((v) => validateAwsRegion(v).isValid, {
-      message: 'Invalid AWS region format (e.g., us-east-1, eu-west-2)',
-    }),
-  accessKeyId: z.string().min(1, 'AWS access key ID is required'),
-  secretAccessKey: z.string().min(1, 'AWS secret access key is required'),
+const BatchGetQueryExecutionSchema = athenaConnectionSchema.extend({
   queryExecutionIds: z
     .array(z.string().trim().min(1))
     .min(1, 'At least one query execution ID is required')

apps/sim/lib/api/contracts/tools/aws/athena-batch-get-prepared-statement.ts

@@ -1,15 +1,13 @@
 import { z } from 'zod'
+import { athenaConnectionSchema } from '@/lib/api/contracts/tools/aws/athena-shared'
 import type {
   ContractBody,
   ContractBodyInput,
   ContractJsonResponse,
 } from '@/lib/api/contracts/types'
 import { defineRouteContract } from '@/lib/api/contracts/types'
 
-const CreateNamedQuerySchema = z.object({
-  region: z.string().min(1, 'AWS region is required'),
-  accessKeyId: z.string().min(1, 'AWS access key ID is required'),
-  secretAccessKey: z.string().min(1, 'AWS secret access key is required'),
+const CreateNamedQuerySchema = athenaConnectionSchema.extend({
   name: z.string().min(1, 'Query name is required'),
   database: z.string().min(1, 'Database is required'),
   queryString: z.string().min(1, 'Query string is required'),

apps/sim/lib/api/contracts/tools/aws/athena-batch-get-query-execution.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod'
+import {
+  athenaConnectionSchema,
+  athenaStatementNameSchema,
+  athenaSuccessResponseSchema,
+  athenaWorkGroupSchema,
+} from '@/lib/api/contracts/tools/aws/athena-shared'
+import type {
+  ContractBody,
+  ContractBodyInput,
+  ContractJsonResponse,
+} from '@/lib/api/contracts/types'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const CreatePreparedStatementSchema = athenaConnectionSchema.extend({
+  statementName: athenaStatementNameSchema,
+  workGroup: athenaWorkGroupSchema,
+  queryStatement: z.string().min(1, 'Query statement is required'),
+  description: z
+    .string()
+    .min(1, 'Description cannot be empty')
+    .max(1024, 'Description must be at most 1024 characters')
+    .optional(),
+})
+
+const CreatePreparedStatementResponseSchema = athenaSuccessResponseSchema
+
+export const awsAthenaCreatePreparedStatementContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/tools/athena/create-prepared-statement',
+  body: CreatePreparedStatementSchema,
+  response: { mode: 'json', schema: CreatePreparedStatementResponseSchema },
+})
+export type AwsAthenaCreatePreparedStatementRequest = ContractBodyInput<
+  typeof awsAthenaCreatePreparedStatementContract
+>
+export type AwsAthenaCreatePreparedStatementBody = ContractBody<
+  typeof awsAthenaCreatePreparedStatementContract
+>
+export type AwsAthenaCreatePreparedStatementResponse = ContractJsonResponse<
+  typeof awsAthenaCreatePreparedStatementContract
+>

apps/sim/lib/api/contracts/tools/aws/athena-create-named-query.ts

@@ -1,21 +1,13 @@
 import { z } from 'zod'
+import { athenaConnectionSchema } from '@/lib/api/contracts/tools/aws/athena-shared'
 import type {
   ContractBody,
   ContractBodyInput,
   ContractJsonResponse,
 } from '@/lib/api/contracts/types'
 import { defineRouteContract } from '@/lib/api/contracts/types'
-import { validateAwsRegion } from '@/lib/core/security/input-validation'
 
-const DeleteNamedQuerySchema = z.object({
-  region: z
-    .string()
-    .min(1, 'AWS region is required')
-    .refine((v) => validateAwsRegion(v).isValid, {
-      message: 'Invalid AWS region format (e.g., us-east-1, eu-west-2)',
-    }),
-  accessKeyId: z.string().min(1, 'AWS access key ID is required'),
-  secretAccessKey: z.string().min(1, 'AWS secret access key is required'),
+const DeleteNamedQuerySchema = athenaConnectionSchema.extend({
   namedQueryId: z.string().trim().min(1, 'Named query ID is required'),
 })
 

apps/sim/lib/api/contracts/tools/aws/athena-create-prepared-statement.ts

@@ -0,0 +1,35 @@
+import {
+  athenaConnectionSchema,
+  athenaStatementNameSchema,
+  athenaSuccessResponseSchema,
+  athenaWorkGroupSchema,
+} from '@/lib/api/contracts/tools/aws/athena-shared'
+import type {
+  ContractBody,
+  ContractBodyInput,
+  ContractJsonResponse,
+} from '@/lib/api/contracts/types'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const DeletePreparedStatementSchema = athenaConnectionSchema.extend({
+  statementName: athenaStatementNameSchema,
+  workGroup: athenaWorkGroupSchema,
+})
+
+const DeletePreparedStatementResponseSchema = athenaSuccessResponseSchema
+
+export const awsAthenaDeletePreparedStatementContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/tools/athena/delete-prepared-statement',
+  body: DeletePreparedStatementSchema,
+  response: { mode: 'json', schema: DeletePreparedStatementResponseSchema },
+})
+export type AwsAthenaDeletePreparedStatementRequest = ContractBodyInput<
+  typeof awsAthenaDeletePreparedStatementContract
+>
+export type AwsAthenaDeletePreparedStatementBody = ContractBody<
+  typeof awsAthenaDeletePreparedStatementContract
+>
+export type AwsAthenaDeletePreparedStatementResponse = ContractJsonResponse<
+  typeof awsAthenaDeletePreparedStatementContract
+>

apps/sim/lib/api/contracts/tools/aws/athena-delete-named-query.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod'
+import {
+  athenaConnectionSchema,
+  athenaOptionalWorkGroupSchema,
+} from '@/lib/api/contracts/tools/aws/athena-shared'
+import type {
+  ContractBody,
+  ContractBodyInput,
+  ContractJsonResponse,
+} from '@/lib/api/contracts/types'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const GetDataCatalogSchema = athenaConnectionSchema.extend({
+  name: z.string().trim().min(1, 'Data catalog name is required'),
+  workGroup: athenaOptionalWorkGroupSchema,
+})
+
+const GetDataCatalogResponseSchema = z.object({
+  success: z.literal(true),
+  output: z.object({
+    name: z.string(),
+    type: z.string(),
+    description: z.string().nullable(),
+    status: z.string().nullable(),
+    connectionType: z.string().nullable(),
+    error: z.string().nullable(),
+    parameters: z.record(z.string(), z.string()),
+  }),
+})
+
+export const awsAthenaGetDataCatalogContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/tools/athena/get-data-catalog',
+  body: GetDataCatalogSchema,
+  response: { mode: 'json', schema: GetDataCatalogResponseSchema },
+})
+export type AwsAthenaGetDataCatalogRequest = ContractBodyInput<
+  typeof awsAthenaGetDataCatalogContract
+>
+export type AwsAthenaGetDataCatalogBody = ContractBody<typeof awsAthenaGetDataCatalogContract>
+export type AwsAthenaGetDataCatalogResponse = ContractJsonResponse<
+  typeof awsAthenaGetDataCatalogContract
+>