@rohithvemulapally/mcp-server-salesforce 0.0.7 → 0.0.8

package/dist/index.js

@@ -19,6 +19,7 @@ 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();
@@ -47,7 +48,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         READ_APEX_TRIGGER,
         WRITE_APEX_TRIGGER,
         EXECUTE_ANONYMOUS,
-        MANAGE_DEBUG_LOGS
+        MANAGE_DEBUG_LOGS,
+        METADATA_QUERY
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -84,6 +86,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
                 return await handleQueryRecords(conn, validatedArgs);
             }
+            case "salesforce_metadata_query": {
+                return await handleMetadataQuery(conn, args);
+            }
             case "salesforce_aggregate_query": {
                 const aggregateArgs = args;
                 if (!aggregateArgs.objectName || !Array.isArray(aggregateArgs.selectFields) || !Array.isArray(aggregateArgs.groupByFields)) {

package/dist/tools/metadata.d.ts

@@ -0,0 +1,9 @@
+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: any;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/metadata.js

@@ -0,0 +1,41 @@
+export const METADATA_QUERY = {
+    name: "salesforce_metadata_query",
+    description: "Fetch validation rules or lightning pages",
+    inputSchema: {
+        type: "object",
+        properties: {
+            metadataType: { type: "string" },
+            objectName: { type: "string" },
+            name: { type: "string" }
+        },
+        required: ["metadataType"]
+    }
+};
+export async function handleMetadataQuery(conn, args) {
+    const { metadataType, objectName, name } = args;
+    try {
+        if (metadataType === "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") {
+            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) {
+        return {
+            content: [{ type: "text", text: error.message }],
+            isError: true
+        };
+    }
+}

package/dist/tools/query.d.ts

@@ -1,4 +1,11 @@
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Tool definition for querying Salesforce records using SOQL.
+ * Supports:
+ * - Standard queries
+ * - Relationship queries
+ * - Automatic switch to Bulk API for large datasets
+ */
 export declare const QUERY_RECORDS: Tool;
 export interface QueryArgs {
     objectName: string;
@@ -7,6 +14,11 @@ export interface QueryArgs {
     orderBy?: string;
     limit?: number;
 }
+/**
+ * Executes query using either:
+ * - Standard API (for aggregates, limits)
+ * - Bulk API (for large datasets)
+ */
 export declare function handleQueryRecords(conn: any, args: QueryArgs): Promise<{
     content: {
         type: string;

package/dist/tools/query.js

@@ -1,125 +1,97 @@
+/**
+ * Tool definition for querying Salesforce records using SOQL.
+ * Supports:
+ * - Standard queries
+ * - Relationship queries
+ * - Automatic switch to Bulk API for large datasets
+ */
 export const QUERY_RECORDS = {
     name: "salesforce_query_records",
     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.
+NOTE:
+- For aggregate queries (COUNT, SUM, GROUP BY), standard query is used.
+- For large datasets, Bulk API is used automatically.
 
 Examples:
-1. Parent-to-child query (e.g., Account with Contacts):
+1. Parent-to-child query:
    - objectName: "Account"
-   - fields: ["Name", "(SELECT Id, FirstName, LastName FROM Contacts)"]
+   - fields: ["Name", "(SELECT Id, FirstName FROM Contacts)"]
 
-2. Child-to-parent query (e.g., Contact with Account details):
+2. Child-to-parent query:
    - objectName: "Contact"
-   - fields: ["FirstName", "LastName", "Account.Name", "Account.Industry"]
+   - fields: ["FirstName", "Account.Name"]
 
-3. Multiple level query (e.g., Contact -> Account -> Owner):
+3. Multi-level relationship:
    - 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")`,
+   - fields: ["Account.Owner.Name"]
+`,
     inputSchema: {
         type: "object",
         properties: {
-            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
-            }
+            objectName: { type: "string" },
+            fields: { type: "array", items: { type: "string" } },
+            whereClause: { type: "string", optional: true },
+            orderBy: { type: "string", optional: true },
+            limit: { type: "number", optional: true }
         },
         required: ["objectName", "fields"]
     }
 };
-// Helper function to validate relationship field syntax
+/**
+ * Validates relationship fields syntax.
+ */
 function validateRelationshipFields(fields) {
     for (const field of fields) {
-        // 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}". Relationship fields should use proper dot notation (e.g., "Account.Name")`
-                };
+            if (parts.some(p => !p)) {
+                return { isValid: false, error: `Invalid field: ${field}` };
             }
-            // Check for too many levels (Salesforce typically limits to 5)
             if (parts.length > 5) {
-                return {
-                    isValid: false,
-                    error: `Relationship field "${field}" exceeds maximum depth of 5 levels`
-                };
+                return { isValid: false, error: `Too deep relationship: ${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: false, error: `Invalid subquery: ${field}` };
         }
     }
     return { isValid: true };
 }
-// Helper function to format relationship query results
+/**
+ * Formats relationship fields for readable output.
+ */
 function formatRelationshipResults(record, field, prefix = '') {
     if (field.includes('.')) {
-        const [relationship, ...rest] = field.split('.');
-        const relatedRecord = record[relationship];
-        if (relatedRecord === null) {
+        const [rel, ...rest] = field.split('.');
+        const related = record[rel];
+        if (!related)
             return `${prefix}${field}: null`;
-        }
-        return formatRelationshipResults(relatedRecord, rest.join('.'), `${prefix}${relationship}.`);
+        return formatRelationshipResults(related, rest.join('.'), `${prefix}${rel}.`);
     }
     const value = record[field];
     if (Array.isArray(value)) {
-        // Handle child relationship arrays
         return `${prefix}${field}: [${value.length} records]`;
     }
-    return `${prefix}${field}: ${value !== null && value !== undefined ? value : 'null'}`;
+    return `${prefix}${field}: ${value ?? 'null'}`;
 }
+/**
+ * Executes query using either:
+ * - Standard API (for aggregates, limits)
+ * - Bulk API (for large datasets)
+ */
 export async function handleQueryRecords(conn, args) {
     const { objectName, fields, whereClause, orderBy, limit } = args;
     try {
-        // Validate relationship field syntax
+        // Step 1: Validate fields
         const validation = validateRelationshipFields(fields);
         if (!validation.isValid) {
             return {
-                content: [{
-                        type: "text",
-                        text: validation.error
-                    }],
-                isError: true,
+                content: [{ type: "text", text: validation.error }],
+                isError: true
             };
         }
-        // Construct SOQL query
+        // Step 2: Build SOQL query
         let soql = `SELECT ${fields.join(', ')} FROM ${objectName}`;
         if (whereClause)
             soql += ` WHERE ${whereClause}`;
@@ -127,54 +99,55 @@ export async function handleQueryRecords(conn, args) {
             soql += ` ORDER BY ${orderBy}`;
         if (limit)
             soql += ` LIMIT ${limit}`;
-        const result = await conn.query(soql);
-        // Format the output
-        const formattedRecords = result.records.map((record, index) => {
+        let records = [];
+        // Step 3: Decide API (Standard vs Bulk)
+        const lower = soql.toLowerCase();
+        if (lower.includes("limit") ||
+            lower.includes("count") ||
+            lower.includes("group by")) {
+            // Use standard REST query
+            const result = await conn.query(soql);
+            records = result.records;
+        }
+        else {
+            // Use Bulk API for large data
+            records = await new Promise((resolve, reject) => {
+                const recs = [];
+                conn.bulk.query(soql)
+                    .on("record", (r) => recs.push(r))
+                    .on("end", () => resolve(recs))
+                    .on("error", reject);
+            });
+        }
+        // Step 4: Format results
+        const formattedRecords = records.map((record, index) => {
             const recordStr = fields.map(field => {
-                // 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]`;
+                    const relName = field.match(/FROM\s+(\w+)/)?.[1];
+                    const child = record[relName];
+                    return `    ${relName}: [${child?.length || 0} records]`;
                 }
                 return '    ' + formatRelationshipResults(record, field);
             }).join('\n');
             return `Record ${index + 1}:\n${recordStr}`;
         }).join('\n\n');
+        // Step 5: Return response
         return {
             content: [{
                     type: "text",
-                    text: `Query returned ${result.records.length} records:\n\n${formattedRecords}`
+                    text: `Query returned ${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`;
-                }
-            }
-        }
+        const msg = error instanceof Error ? error.message : String(error);
         return {
             content: [{
                     type: "text",
-                    text: `Error executing query: ${enhancedError}`
+                    text: `Error executing query: ${msg}`
                 }],
-            isError: true,
+            isError: true
         };
     }
 }

package/package.json

@@ -1,39 +1,38 @@
 {
     "name": "@rohithvemulapally/mcp-server-salesforce",
-    "version": "0.0.7",
+    "version": "0.0.8",
     "description": "A Salesforce connector MCP Server.",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "module",
     "bin": {
-      "salesforce-connector": "dist/index.js"
+        "salesforce-connector": "dist/index.js"
     },
     "files": [
-      "dist"
+        "dist"
     ],
     "scripts": {
-      "build": "tsc && shx chmod +x dist/*.js",
-      "prepare": "npm run build",
-      "watch": "tsc --watch",
-      "test": "node --test"
+        "build": "tsc && shx chmod +x dist/*.js",
+        "prepare": "npm run build",
+        "watch": "tsc --watch",
+        "test": "node --test"
     },
     "keywords": [
-      "mcp",
-      "salesforce",
-      "claude",
-      "ai"
+        "mcp",
+        "salesforce",
+        "claude",
+        "ai"
     ],
     "author": "rohithvemulapally",
     "license": "MIT",
     "dependencies": {
-      "@modelcontextprotocol/sdk": "1.22.0",
-      "dotenv": "16.4.7",
-      "jsforce": "^3.10.3"
+        "@modelcontextprotocol/sdk": "1.22.0",
+        "dotenv": "16.4.7",
+        "jsforce": "^3.10.3"
     },
     "devDependencies": {
-      "@types/node": "^24.3.0",
-      "typescript": "^5.7.2",
-      "shx": "^0.4.0"
+        "@types/node": "^24.3.0",
+        "typescript": "^5.7.2",
+        "shx": "^0.4.0"
     }
-  }
-  
+}