@rohithvemulapally/mcp-server-salesforce 0.0.6 → 0.0.7

package/dist/index.js

@@ -19,7 +19,6 @@ import { READ_APEX_TRIGGER, handleReadApexTrigger } from "./tools/readApexTrigge
 import { WRITE_APEX_TRIGGER, handleWriteApexTrigger } from "./tools/writeApexTrigger.js";
 import { EXECUTE_ANONYMOUS, handleExecuteAnonymous } from "./tools/executeAnonymous.js";
 import { MANAGE_DEBUG_LOGS, handleManageDebugLogs } from "./tools/manageDebugLogs.js";
-import { METADATA_QUERY, handleMetadataQuery } from "./tools/metadata";
 // Load environment variables (using dotenv 16.x which has no stdout tips)
 // MCP servers require stdout to contain ONLY JSON-RPC messages
 dotenv.config();
@@ -48,8 +47,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         READ_APEX_TRIGGER,
         WRITE_APEX_TRIGGER,
         EXECUTE_ANONYMOUS,
-        MANAGE_DEBUG_LOGS,
-        METADATA_QUERY
+        MANAGE_DEBUG_LOGS
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -252,9 +250,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
                 return await handleWriteApexTrigger(conn, validatedArgs);
             }
-            case "salesforce_metadata_query": {
-                return await handleMetadataQuery(conn, args);
-            }
             case "salesforce_execute_anonymous": {
                 const executeArgs = args;
                 if (!executeArgs.apexCode) {

package/dist/tools/query.js

@@ -1,114 +1,180 @@
-// Bulk API query for large datasets
-async function bulkQuery(conn, soql) {
-    return new Promise((resolve, reject) => {
-        const records = [];
-        conn.bulk.query(soql)
-            .on("record", (record) => records.push(record))
-            .on("end", () => resolve(records))
-            .on("error", (err) => reject(err));
-    });
-}
 export const QUERY_RECORDS = {
     name: "salesforce_query_records",
-    description: "Query records from any Salesforce object using SOQL",
+    description: `Query records from any Salesforce object using SOQL, including relationship queries.
+
+NOTE: For queries with GROUP BY, aggregate functions (COUNT, SUM, AVG, etc.), or HAVING clauses, use salesforce_aggregate_query instead.
+
+Examples:
+1. Parent-to-child query (e.g., Account with Contacts):
+   - objectName: "Account"
+   - fields: ["Name", "(SELECT Id, FirstName, LastName FROM Contacts)"]
+
+2. Child-to-parent query (e.g., Contact with Account details):
+   - objectName: "Contact"
+   - fields: ["FirstName", "LastName", "Account.Name", "Account.Industry"]
+
+3. Multiple level query (e.g., Contact -> Account -> Owner):
+   - objectName: "Contact"
+   - fields: ["Name", "Account.Name", "Account.Owner.Name"]
+
+4. Related object filtering:
+   - objectName: "Contact"
+   - fields: ["Name", "Account.Name"]
+   - whereClause: "Account.Industry = 'Technology'"
+
+Note: When using relationship fields:
+- Use dot notation for parent relationships (e.g., "Account.Name")
+- Use subqueries in parentheses for child relationships (e.g., "(SELECT Id FROM Contacts)")
+- Custom relationship fields end in "__r" (e.g., "CustomObject__r.Name")`,
     inputSchema: {
         type: "object",
         properties: {
-            objectName: { type: "string" },
-            fields: { type: "array", items: { type: "string" } },
-            whereClause: { type: "string", optional: true },
-            orderBy: { type: "string", optional: true },
-            limit: { type: "number", optional: true }
+            objectName: {
+                type: "string",
+                description: "API name of the object to query"
+            },
+            fields: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of fields to retrieve, including relationship fields"
+            },
+            whereClause: {
+                type: "string",
+                description: "WHERE clause, can include conditions on related objects",
+                optional: true
+            },
+            orderBy: {
+                type: "string",
+                description: "ORDER BY clause, can include fields from related objects",
+                optional: true
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of records to return",
+                optional: true
+            }
         },
         required: ["objectName", "fields"]
     }
 };
+// Helper function to validate relationship field syntax
 function validateRelationshipFields(fields) {
     for (const field of fields) {
-        if (field.includes(".")) {
-            const parts = field.split(".");
+        // Check for parent relationship syntax (dot notation)
+        if (field.includes('.')) {
+            const parts = field.split('.');
+            // Check for empty parts
             if (parts.some(part => !part)) {
-                return { isValid: false, error: `Invalid relationship field format: "${field}"` };
+                return {
+                    isValid: false,
+                    error: `Invalid relationship field format: "${field}". Relationship fields should use proper dot notation (e.g., "Account.Name")`
+                };
             }
+            // Check for too many levels (Salesforce typically limits to 5)
             if (parts.length > 5) {
-                return { isValid: false, error: `Relationship field "${field}" exceeds maximum depth` };
+                return {
+                    isValid: false,
+                    error: `Relationship field "${field}" exceeds maximum depth of 5 levels`
+                };
             }
         }
-        if (field.includes("SELECT") && !field.match(/^\(SELECT.*FROM.*\)$/)) {
-            return { isValid: false, error: `Invalid subquery format: "${field}"` };
+        // Check for child relationship syntax (subqueries)
+        if (field.includes('SELECT') && !field.match(/^\(SELECT.*FROM.*\)$/)) {
+            return {
+                isValid: false,
+                error: `Invalid subquery format: "${field}". Child relationship queries should be wrapped in parentheses`
+            };
         }
     }
     return { isValid: true };
 }
-function formatRelationshipResults(record, field, prefix = "") {
-    if (field.includes(".")) {
-        const [relationship, ...rest] = field.split(".");
+// Helper function to format relationship query results
+function formatRelationshipResults(record, field, prefix = '') {
+    if (field.includes('.')) {
+        const [relationship, ...rest] = field.split('.');
         const relatedRecord = record[relationship];
-        if (relatedRecord === null)
+        if (relatedRecord === null) {
             return `${prefix}${field}: null`;
-        return formatRelationshipResults(relatedRecord, rest.join("."), `${prefix}${relationship}.`);
+        }
+        return formatRelationshipResults(relatedRecord, rest.join('.'), `${prefix}${relationship}.`);
     }
     const value = record[field];
     if (Array.isArray(value)) {
+        // Handle child relationship arrays
         return `${prefix}${field}: [${value.length} records]`;
     }
-    return `${prefix}${field}: ${value ?? "null"}`;
+    return `${prefix}${field}: ${value !== null && value !== undefined ? value : 'null'}`;
 }
 export async function handleQueryRecords(conn, args) {
     const { objectName, fields, whereClause, orderBy, limit } = args;
     try {
+        // Validate relationship field syntax
         const validation = validateRelationshipFields(fields);
         if (!validation.isValid) {
             return {
-                content: [{ type: "text", text: validation.error }],
-                isError: true
+                content: [{
+                        type: "text",
+                        text: validation.error
+                    }],
+                isError: true,
             };
         }
-        let soql = `SELECT ${fields.join(", ")} FROM ${objectName}`;
+        // Construct SOQL query
+        let soql = `SELECT ${fields.join(', ')} FROM ${objectName}`;
         if (whereClause)
             soql += ` WHERE ${whereClause}`;
         if (orderBy)
             soql += ` ORDER BY ${orderBy}`;
         if (limit)
             soql += ` LIMIT ${limit}`;
-        let records = [];
-        const lower = soql.toLowerCase();
-        if (lower.includes("limit") ||
-            lower.includes("count") ||
-            lower.includes("group by")) {
-            const result = await conn.query(soql);
-            records = result.records;
-        }
-        else {
-            records = await bulkQuery(conn, soql);
-        }
-        const formattedRecords = records.map((record, index) => {
+        const result = await conn.query(soql);
+        // Format the output
+        const formattedRecords = result.records.map((record, index) => {
             const recordStr = fields.map(field => {
-                if (field.startsWith("(SELECT")) {
+                // Handle special case for subqueries (child relationships)
+                if (field.startsWith('(SELECT')) {
                     const relationshipName = field.match(/FROM\s+(\w+)/)?.[1];
+                    if (!relationshipName)
+                        return `    ${field}: Invalid subquery format`;
                     const childRecords = record[relationshipName];
                     return `    ${relationshipName}: [${childRecords?.length || 0} records]`;
                 }
-                return "    " + formatRelationshipResults(record, field);
-            }).join("\n");
+                return '    ' + formatRelationshipResults(record, field);
+            }).join('\n');
             return `Record ${index + 1}:\n${recordStr}`;
-        }).join("\n\n");
+        }).join('\n\n');
         return {
             content: [{
                     type: "text",
-                    text: `Query returned ${records.length} records:\n\n${formattedRecords}`
+                    text: `Query returned ${result.records.length} records:\n\n${formattedRecords}`
                 }],
-            isError: false
+            isError: false,
         };
     }
     catch (error) {
+        // Enhanced error handling for relationship queries
         const errorMessage = error instanceof Error ? error.message : String(error);
+        let enhancedError = errorMessage;
+        if (errorMessage.includes('INVALID_FIELD')) {
+            // Try to identify which relationship field caused the error
+            const fieldMatch = errorMessage.match(/(?:No such column |Invalid field: )['"]?([^'")\s]+)/);
+            if (fieldMatch) {
+                const invalidField = fieldMatch[1];
+                if (invalidField.includes('.')) {
+                    enhancedError = `Invalid relationship field "${invalidField}". Please check:\n` +
+                        `1. The relationship name is correct\n` +
+                        `2. The field exists on the related object\n` +
+                        `3. You have access to the field\n` +
+                        `4. For custom relationships, ensure you're using '__r' suffix`;
+                }
+            }
+        }
         return {
             content: [{
                     type: "text",
-                    text: `Error executing query: ${errorMessage}`
+                    text: `Error executing query: ${enhancedError}`
                 }],
-            isError: true
+            isError: true,
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rohithvemulapally/mcp-server-salesforce",
-    "version": "0.0.6",
+    "version": "0.0.7",
     "description": "A Salesforce connector MCP Server.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",

package/dist/tools/metadata.d.ts

@@ -1,9 +0,0 @@
-import { Tool } from "@modelcontextprotocol/sdk/types.js";
-export declare const METADATA_QUERY: Tool;
-export declare function handleMetadataQuery(conn: any, args: any): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-}>;

package/dist/tools/metadata.js

@@ -1,66 +0,0 @@
-export const METADATA_QUERY = {
-    name: "salesforce_metadata_query",
-    description: "Fetch Salesforce metadata such as validation rules and Lightning record pages",
-    inputSchema: {
-        type: "object",
-        properties: {
-            metadataType: {
-                type: "string",
-                description: "Type of metadata: ValidationRule or FlexiPage"
-            },
-            objectName: {
-                type: "string",
-                description: "Object name (required for ValidationRule)"
-            },
-            name: {
-                type: "string",
-                description: "Metadata name (required for FlexiPage)"
-            }
-        },
-        required: ["metadataType"]
-    }
-};
-export async function handleMetadataQuery(conn, args) {
-    const { metadataType, objectName, name } = args;
-    try {
-        if (metadataType === "ValidationRule") {
-            if (!objectName) {
-                throw new Error("objectName is required for ValidationRule");
-            }
-            const result = await conn.tooling.query(`SELECT Id, ValidationName, ErrorMessage, Active 
-         FROM ValidationRule 
-         WHERE EntityDefinition.QualifiedApiName = '${objectName}'`);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result.records, null, 2)
-                    }],
-                isError: false
-            };
-        }
-        if (metadataType === "FlexiPage") {
-            if (!name) {
-                throw new Error("name is required for FlexiPage");
-            }
-            const result = await conn.metadata.read("FlexiPage", name);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result, null, 2)
-                    }],
-                isError: false
-            };
-        }
-        throw new Error("Unsupported metadata type");
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error fetching metadata: ${errorMessage}`
-                }],
-            isError: true
-        };
-    }
-}