salesforce_read_apex

Instructions

Implementation Reference

• src/tools/readApex.ts:83-188 (handler)

  Main handler function that implements the core logic for reading Apex classes or listing them from Salesforce using SOQL queries on ApexClass object.

  export async function handleReadApex(conn: any, args: ReadApexArgs) {
    try {
      // If a specific class name is provided, get the full class body
      if (args.className) {
        console.error(`Reading Apex class: ${args.className}`);
        
        // Query the ApexClass object to get the class body
        const result = await conn.query(`
          SELECT Id, Name, Body, ApiVersion, LengthWithoutComments, Status, 
                 IsValid, LastModifiedDate, LastModifiedById
          FROM ApexClass 
          WHERE Name = '${args.className}'
        `);
        
        if (result.records.length === 0) {
          return {
            content: [{ 
              type: "text", 
              text: `No Apex class found with name: ${args.className}` 
            }],
            isError: true,
          };
        }
        
        const apexClass = result.records[0];
        
        // Format the response with the class body and metadata
        return {
          content: [
            { 
              type: "text", 
              text: `# Apex Class: ${apexClass.Name}\n\n` +
                    (args.includeMetadata ? 
                      `**API Version:** ${apexClass.ApiVersion}\n` +
                      `**Length:** ${apexClass.LengthWithoutComments} characters\n` +
                      `**Status:** ${apexClass.Status}\n` +
                      `**Valid:** ${apexClass.IsValid ? 'Yes' : 'No'}\n` +
                      `**Last Modified:** ${new Date(apexClass.LastModifiedDate).toLocaleString()}\n\n` : '') +
                    "```apex\n" + apexClass.Body + "\n```"
            }
          ]
        };
      } 
      // Otherwise, list classes matching the pattern
      else {
        console.error(`Listing Apex classes${args.namePattern ? ` matching: ${args.namePattern}` : ''}`);
        
        // Build the query
        let query = `
          SELECT Id, Name${args.includeMetadata ? ', ApiVersion, LengthWithoutComments, Status, IsValid, LastModifiedDate' : ''}
          FROM ApexClass
        `;
        
        // Add name pattern filter if provided
        if (args.namePattern) {
          const likePattern = wildcardToLikePattern(args.namePattern);
          query += ` WHERE Name LIKE '${likePattern}'`;
        }
        
        // Order by name
        query += ` ORDER BY Name`;
        
        const result = await conn.query(query);
        
        if (result.records.length === 0) {
          return {
            content: [{ 
              type: "text", 
              text: `No Apex classes found${args.namePattern ? ` matching: ${args.namePattern}` : ''}` 
            }]
          };
        }
        
        // Format the response as a list of classes
        let responseText = `# Found ${result.records.length} Apex Classes\n\n`;
        
        if (args.includeMetadata) {
          // Table format with metadata
          responseText += "| Name | API Version | Length | Status | Valid | Last Modified |\n";
          responseText += "|------|------------|--------|--------|-------|---------------|\n";
          
          for (const cls of result.records) {
            responseText += `| ${cls.Name} | ${cls.ApiVersion} | ${cls.LengthWithoutComments} | ${cls.Status} | ${cls.IsValid ? 'Yes' : 'No'} | ${new Date(cls.LastModifiedDate).toLocaleString()} |\n`;
          }
        } else {
          // Simple list format
          for (const cls of result.records) {
            responseText += `- ${cls.Name}\n`;
          }
        }
        
        return {
          content: [{ type: "text", text: responseText }]
        };
      }
    } catch (error) {
      console.error('Error reading Apex classes:', error);
      return {
        content: [{ 
          type: "text", 
          text: `Error reading Apex classes: ${error instanceof Error ? error.message : String(error)}` 
        }],
        isError: true,
      };
    }
  }

• src/tools/readApex.ts:3-52 (schema)

  Tool schema definition including name, description, and input schema for validating arguments.

  export const READ_APEX: Tool = {
    name: "salesforce_read_apex",
    description: `Read Apex classes from Salesforce.
    
  Examples:
  1. Read a specific Apex class by name:
     {
       "className": "AccountController"
     }
  
  2. List all Apex classes with an optional name pattern:
     {
       "namePattern": "Controller"
     }
  
  3. Get metadata about Apex classes:
     {
       "includeMetadata": true,
       "namePattern": "Trigger"
     }
  
  4. Use wildcards in name patterns:
     {
       "namePattern": "Account*Cont*"
     }
  
  Notes:
  - When className is provided, the full body of that specific class is returned
  - When namePattern is provided, all matching class names are returned (without body)
  - Use includeMetadata to get additional information like API version, length, and last modified date
  - If neither className nor namePattern is provided, all Apex class names will be listed
  - Wildcards are supported in namePattern: * (matches any characters) and ? (matches a single character)`,
    inputSchema: {
      type: "object",
      properties: {
        className: {
          type: "string",
          description: "Name of a specific Apex class to read"
        },
        namePattern: {
          type: "string",
          description: "Pattern to match Apex class names (supports wildcards * and ?)"
        },
        includeMetadata: {
          type: "boolean",
          description: "Whether to include metadata about the Apex classes"
        }
      }
    }
  };

• src/index.ts:227-238 (registration)

  Registration in the main switch dispatcher that maps tool calls to the handleReadApex function.

  case "salesforce_read_apex": {
    const apexArgs = args as Record<string, unknown>;
    
    // Type check and conversion
    const validatedArgs: ReadApexArgs = {
      className: apexArgs.className as string | undefined,
      namePattern: apexArgs.namePattern as string | undefined,
      includeMetadata: apexArgs.includeMetadata as boolean | undefined
    };
  
    return await handleReadApex(conn, validatedArgs);
  }

• src/tools/readApex.ts:65-75 (helper)

  Helper function to convert wildcard patterns (*, ?) to SQL LIKE patterns for querying Apex class names.

  function wildcardToLikePattern(pattern: string): string {
    if (!pattern.includes('*') && !pattern.includes('?')) {
      // If no wildcards, wrap with % for substring match
      return `%${pattern}%`;
    }
    
    // Replace * with % and ? with _ for SQL LIKE
    let likePattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
    
    return likePattern;
  }

• src/index.ts:45-62 (registration)

  Tool registration in the listTools handler, including READ_APEX in the exported tools list.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      SEARCH_OBJECTS, 
      DESCRIBE_OBJECT, 
      QUERY_RECORDS, 
      AGGREGATE_QUERY,
      DML_RECORDS,
      MANAGE_OBJECT,
      MANAGE_FIELD,
      MANAGE_FIELD_PERMISSIONS,
      SEARCH_ALL,
      READ_APEX,
      WRITE_APEX,
      READ_APEX_TRIGGER,
      WRITE_APEX_TRIGGER,
      EXECUTE_ANONYMOUS,
      MANAGE_DEBUG_LOGS
    ],