@rohithvemulapally/mcp-server-salesforce 0.0.6 → 0.0.8

package/dist/index.js

@@ -86,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)) {
@@ -252,9 +255,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/metadata.d.ts

@@ -3,7 +3,7 @@ export declare const METADATA_QUERY: Tool;
 export declare function handleMetadataQuery(conn: any, args: any): Promise<{
     content: {
         type: string;
-        text: string;
+        text: any;
     }[];
     isError: boolean;
 }>;

package/dist/tools/metadata.js

@@ -1,21 +1,12 @@
 export const METADATA_QUERY = {
     name: "salesforce_metadata_query",
-    description: "Fetch Salesforce metadata such as validation rules and Lightning record pages",
+    description: "Fetch validation rules or lightning 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)"
-            }
+            metadataType: { type: "string" },
+            objectName: { type: "string" },
+            name: { type: "string" }
         },
         required: ["metadataType"]
     }
@@ -24,42 +15,26 @@ 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)
-                    }],
+                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)
-                    }],
+                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}`
-                }],
+            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,16 +1,31 @@
-// 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));
-    });
-}
+/**
+ * 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",
+    description: `Query records from any Salesforce object using SOQL, including relationship queries.
+
+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:
+   - objectName: "Account"
+   - fields: ["Name", "(SELECT Id, FirstName FROM Contacts)"]
+
+2. Child-to-parent query:
+   - objectName: "Contact"
+   - fields: ["FirstName", "Account.Name"]
+
+3. Multi-level relationship:
+   - objectName: "Contact"
+   - fields: ["Account.Owner.Name"]
+`,
     inputSchema: {
         type: "object",
         properties: {
@@ -23,40 +38,52 @@ export const QUERY_RECORDS = {
         required: ["objectName", "fields"]
     }
 };
+/**
+ * Validates relationship fields syntax.
+ */
 function validateRelationshipFields(fields) {
     for (const field of fields) {
-        if (field.includes(".")) {
-            const parts = field.split(".");
-            if (parts.some(part => !part)) {
-                return { isValid: false, error: `Invalid relationship field format: "${field}"` };
+        if (field.includes('.')) {
+            const parts = field.split('.');
+            if (parts.some(p => !p)) {
+                return { isValid: false, error: `Invalid field: ${field}` };
             }
             if (parts.length > 5) {
-                return { isValid: false, error: `Relationship field "${field}" exceeds maximum depth` };
+                return { isValid: false, error: `Too deep relationship: ${field}` };
             }
         }
-        if (field.includes("SELECT") && !field.match(/^\(SELECT.*FROM.*\)$/)) {
-            return { isValid: false, error: `Invalid subquery format: "${field}"` };
+        if (field.includes('SELECT') && !field.match(/^\(SELECT.*FROM.*\)$/)) {
+            return { isValid: false, error: `Invalid subquery: ${field}` };
         }
     }
     return { isValid: true };
 }
-function formatRelationshipResults(record, field, prefix = "") {
-    if (field.includes(".")) {
-        const [relationship, ...rest] = field.split(".");
-        const relatedRecord = record[relationship];
-        if (relatedRecord === null)
+/**
+ * Formats relationship fields for readable output.
+ */
+function formatRelationshipResults(record, field, prefix = '') {
+    if (field.includes('.')) {
+        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)) {
         return `${prefix}${field}: [${value.length} records]`;
     }
-    return `${prefix}${field}: ${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 {
+        // Step 1: Validate fields
         const validation = validateRelationshipFields(fields);
         if (!validation.isValid) {
             return {
@@ -64,7 +91,8 @@ export async function handleQueryRecords(conn, args) {
                 isError: true
             };
         }
-        let soql = `SELECT ${fields.join(", ")} FROM ${objectName}`;
+        // Step 2: Build SOQL query
+        let soql = `SELECT ${fields.join(', ')} FROM ${objectName}`;
         if (whereClause)
             soql += ` WHERE ${whereClause}`;
         if (orderBy)
@@ -72,27 +100,38 @@ export async function handleQueryRecords(conn, args) {
         if (limit)
             soql += ` LIMIT ${limit}`;
         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 {
-            records = await bulkQuery(conn, soql);
+            // 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 => {
-                if (field.startsWith("(SELECT")) {
-                    const relationshipName = field.match(/FROM\s+(\w+)/)?.[1];
-                    const childRecords = record[relationshipName];
-                    return `    ${relationshipName}: [${childRecords?.length || 0} records]`;
+                if (field.startsWith('(SELECT')) {
+                    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 '    ' + formatRelationshipResults(record, field);
+            }).join('\n');
             return `Record ${index + 1}:\n${recordStr}`;
-        }).join("\n\n");
+        }).join('\n\n');
+        // Step 5: Return response
         return {
             content: [{
                     type: "text",
@@ -102,11 +141,11 @@ export async function handleQueryRecords(conn, args) {
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const msg = error instanceof Error ? error.message : String(error);
         return {
             content: [{
                     type: "text",
-                    text: `Error executing query: ${errorMessage}`
+                    text: `Error executing query: ${msg}`
                 }],
             isError: true
         };

package/package.json

@@ -1,39 +1,38 @@
 {
     "name": "@rohithvemulapally/mcp-server-salesforce",
-    "version": "0.0.6",
+    "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"
     }
-  }
-  
+}