execute_procedure

Instructions

Implementation Reference

• src/tools/execute-procedure.ts:6-56 (handler)

  Core handler function that executes a stored procedure using a DatabaseConnection. Connects to the pool, sanitizes parameters via sanitizeParameters, calls request.execute() with schemaName.procedureName, and returns a CallToolResult with procedure metadata (recordsets, output, returnValue, rowsAffected). Handles errors with a Portuguese error message.

  export async function executeProcedure(
    db: DatabaseConnection,
    procedureName: string,
    parameters?: Record<string, unknown>,
    schemaName: string = 'dbo'
  ): Promise<CallToolResult> {
    try {
      const pool = db.getPool()
      const request = pool.request()
  
      if (parameters) {
        const sanitizedParams = sanitizeParameters(parameters)
  
        for (const [key, value] of Object.entries(sanitizedParams)) {
          request.input(key, value)
        }
      }
  
      const result = await request.execute(`${schemaName}.${procedureName}`)
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(
              {
                procedure: `${schemaName}.${procedureName}`,
                recordsets: result.recordsets,
                recordset: result.recordset,
                output: result.output || {},
                returnValue: result.returnValue,
                rowsAffected: result.rowsAffected,
              },
              null,
              2
            ),
          },
        ],
      }
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Erro: ${error instanceof Error ? error.message : 'Erro desconhecido'}`,
          },
        ],
        isError: true,
      }
    }
  }

• src/schemas.ts:55-62 (schema)

  Zod input schema for execute_procedure. Defines procedureName (string), parameters (optional record of string->unknown), and schemaName (default 'dbo').

  export const executeProcedureInput = z.object({
    procedureName: z.string().describe('Name of the stored procedure to execute'),
    parameters: z
      .record(z.string(), z.unknown())
      .optional()
      .describe('Procedure parameters'),
    schemaName: z.string().default('dbo').describe('Schema name (default: dbo)'),
  })

• src/tools/index.ts:69-75 (registration)

  Registration of execute_procedure in the toolsList() array with name 'execute_procedure', description, and inputSchema converted from Zod to JSON Schema.

      {
        name: 'execute_procedure',
        description: 'Executes a stored procedure with parameters',
        inputSchema: zodToJsonSchema(executeProcedureInput),
      },
    ]
  }

• src/services/SqlServerMCPService.ts:78-81 (registration)

  Handler map registration connecting 'execute_procedure' string to the executeProcedure function, parsing args as ExecuteProcedureInput.

  handlers.set('execute_procedure', async (database, args) => {
    const { procedureName, parameters } = args as ExecuteProcedureInput
    return await executeProcedure(database, procedureName, parameters ?? {})
  })

• src/utils/sanitize-parameters.ts:1-19 (helper)

  Helper function that validates parameter names (alphanumeric/underscore regex) and enforces max string length of 8000 characters before passing to the SQL request.

  export function sanitizeParameters(
    parameters: Record<string, unknown>
  ): Record<string, unknown> {
    const sanitized: Record<string, unknown> = {}
  
    for (const [key, value] of Object.entries(parameters)) {
      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
        throw new Error(`Nome de parâmetro inválido: ${key}`)
      }
  
      if (typeof value === 'string' && value.length > 8000) {
        throw new Error(`Valor muito longo para parâmetro: ${key}`)
      }
  
      sanitized[key] = value
    }
  
    return sanitized
  }