salesforce_manage_object

Instructions

Implementation Reference

• src/tools/manageObject.ts:75-163 (handler)

  The core handler function `handleManageObject` that executes the tool logic: creates or updates Salesforce custom objects using the Metadata API, handles validation, metadata preparation, API calls, and error handling.

  export async function handleManageObject(conn: any, args: ManageObjectArgs) {
    const { operation, objectName, label, pluralLabel, description, nameFieldLabel, nameFieldType, nameFieldFormat, sharingModel } = args;
  
    try {
      if (operation === 'create') {
        if (!label || !pluralLabel) {
          throw new Error('Label and pluralLabel are required for object creation');
        }
  
        // Prepare metadata for the new object
        const metadata = {
          fullName: `${objectName}__c`,
          label,
          pluralLabel,
          nameField: {
            label: nameFieldLabel || `${label} Name`,
            type: nameFieldType || 'Text',
            ...(nameFieldType === 'AutoNumber' && nameFieldFormat ? { displayFormat: nameFieldFormat } : {})
          },
          deploymentStatus: 'Deployed',
          sharingModel: sharingModel || 'ReadWrite'
        } as MetadataInfo;
  
        if (description) {
          metadata.description = description;
        }
  
        // Create the object using Metadata API
        const result = await conn.metadata.create('CustomObject', metadata);
  
        if (result && (Array.isArray(result) ? result[0].success : result.success)) {
          return {
            content: [{
              type: "text",
              text: `Successfully created custom object ${objectName}__c`
            }],
            isError: false,
          };
        }
      } else {
        // For update, first get existing metadata
        const existingMetadata = await conn.metadata.read('CustomObject', [`${objectName}__c`]);
        const currentMetadata = Array.isArray(existingMetadata) ? existingMetadata[0] : existingMetadata;
  
        if (!currentMetadata) {
          throw new Error(`Object ${objectName}__c not found`);
        }
  
        // Prepare update metadata
        const metadata = {
          ...currentMetadata,
          label: label || currentMetadata.label,
          pluralLabel: pluralLabel || currentMetadata.pluralLabel,
          description: description !== undefined ? description : currentMetadata.description,
          sharingModel: sharingModel || currentMetadata.sharingModel
        } as MetadataInfo;
  
        // Update the object using Metadata API
        const result = await conn.metadata.update('CustomObject', metadata);
  
        if (result && (Array.isArray(result) ? result[0].success : result.success)) {
          return {
            content: [{
              type: "text",
              text: `Successfully updated custom object ${objectName}__c`
            }],
            isError: false,
          };
        }
      }
  
      return {
        content: [{
          type: "text",
          text: `Failed to ${operation} custom object ${objectName}__c`
        }],
        isError: true,
      };
  
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: `Error ${operation === 'create' ? 'creating' : 'updating'} custom object: ${error instanceof Error ? error.message : String(error)}`
        }],
        isError: true,
      };
    }
  }

• src/tools/manageObject.ts:4-61 (schema)

  The `MANAGE_OBJECT` tool definition containing the input schema for validating tool parameters like operation, objectName, labels, and sharing model.

  export const MANAGE_OBJECT: Tool = {
    name: "salesforce_manage_object",
    description: `Create new custom objects or modify existing ones in Salesforce:
    - Create: New custom objects with fields, relationships, and settings
    - Update: Modify existing object settings, labels, sharing model
    Examples: Create Customer_Feedback__c object, Update object sharing settings
    Note: Changes affect metadata and require proper permissions`,
    inputSchema: {
      type: "object",
      properties: {
        operation: {
          type: "string",
          enum: ["create", "update"],
          description: "Whether to create new object or update existing"
        },
        objectName: {
          type: "string",
          description: "API name for the object (without __c suffix)"
        },
        label: {
          type: "string",
          description: "Label for the object"
        },
        pluralLabel: {
          type: "string",
          description: "Plural label for the object"
        },
        description: {
          type: "string",
          description: "Description of the object",
          optional: true
        },
        nameFieldLabel: {
          type: "string",
          description: "Label for the name field",
          optional: true
        },
        nameFieldType: {
          type: "string",
          enum: ["Text", "AutoNumber"],
          description: "Type of the name field",
          optional: true
        },
        nameFieldFormat: {
          type: "string",
          description: "Display format for AutoNumber field (e.g., 'A-{0000}')",
          optional: true
        },
        sharingModel: {
          type: "string",
          enum: ["ReadWrite", "Read", "Private", "ControlledByParent"],
          description: "Sharing model for the object",
          optional: true
        }
      },
      required: ["operation", "objectName"]
    }
  };

• src/index.ts:133-150 (registration)

  Registration in the main tool dispatch switch statement: validates input arguments and invokes the `handleManageObject` handler.

  case "salesforce_manage_object": {
    const objectArgs = args as Record<string, unknown>;
    if (!objectArgs.operation || !objectArgs.objectName) {
      throw new Error('operation and objectName are required for object management');
    }
    const validatedArgs: ManageObjectArgs = {
      operation: objectArgs.operation as 'create' | 'update',
      objectName: objectArgs.objectName as string,
      label: objectArgs.label as string | undefined,
      pluralLabel: objectArgs.pluralLabel as string | undefined,
      description: objectArgs.description as string | undefined,
      nameFieldLabel: objectArgs.nameFieldLabel as string | undefined,
      nameFieldType: objectArgs.nameFieldType as 'Text' | 'AutoNumber' | undefined,
      nameFieldFormat: objectArgs.nameFieldFormat as string | undefined,
      sharingModel: objectArgs.sharingModel as 'ReadWrite' | 'Read' | 'Private' | 'ControlledByParent' | undefined
    };
    return await handleManageObject(conn, validatedArgs);
  }

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

  The tool is registered in the listTools response by including `MANAGE_OBJECT` in the tools array, making it discoverable via MCP.

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: [
      SEARCH_OBJECTS, 
      DESCRIBE_OBJECT, 
      QUERY_RECORDS, 
      AGGREGATE_QUERY,
      DML_RECORDS,
      MANAGE_OBJECT,

• src/index.ts:17-17 (registration)

  Import statement that brings in the tool definition, handler, and types from the implementation file.

  import { MANAGE_OBJECT, handleManageObject, ManageObjectArgs } from "./tools/manageObject.js";