getv2dataprivacydataforemailaddress

Instructions

Implementation Reference

• src/index.ts:273-382 (handler)

  The generic handler function executeApiTool that implements the core logic for all tools, including getv2dataprivacydataforemailaddress. It validates input using Zod schema from inputSchema, builds the API URL (https://api.gong.io/v2/data-privacy/data-for-email-address with query params emailAddress and cursor), uses Basic Auth from GONG_ACCESS_KEY and GONG_SECRET env vars, makes axios GET request, and returns the JSON response.

  async function executeApiTool(
      toolName: string,
      definition: McpToolDefinition,
      toolArgs: JsonObject,
      allSecuritySchemes: Record<string, any>
  ): Promise<CallToolResult> {
      try {
          // Validate input arguments using Zod
          const zodSchema = getZodSchemaFromJsonSchema(definition.inputSchema, toolName);
          const validatedArgs = zodSchema.parse(toolArgs);
  
          // Build the request URL
          let url = API_BASE_URL + definition.pathTemplate;
          
          // Replace path parameters
          for (const param of definition.executionParameters) {
              if (param.in === 'path') {
                  const value = validatedArgs[param.name];
                  if (value !== undefined) {
                      url = url.replace(`{${param.name}}`, encodeURIComponent(value));
                  }
              }
          }
  
          // Build query parameters
          const queryParams: Record<string, string> = {};
          for (const param of definition.executionParameters) {
              if (param.in === 'query') {
                  const value = validatedArgs[param.name];
                  if (value !== undefined) {
                      queryParams[param.name] = value;
                  }
              }
          }
          
          if (Object.keys(queryParams).length > 0) {
              url += '?' + new URLSearchParams(queryParams).toString();
          }
  
          // Debug logging (safe)
          console.error('Debug - Making API request to:', url);
          
          // Get credentials from environment
          const accessKey = process.env.GONG_ACCESS_KEY || '';
          const secret = process.env.GONG_SECRET || '';
          
          if (!accessKey || !secret) {
              throw new Error('Missing Gong credentials in environment');
          }
          
          // Create authorization header
          const authHeader = `Basic ${Buffer.from(`${accessKey}:${secret}`).toString('base64')}`;
          
          // Build request config
          const config: AxiosRequestConfig = {
              method: definition.method,
              url,
              headers: {
                  'Accept': 'application/json',
                  'Authorization': authHeader
              }
          };
  
          // Add request body if needed
          if (definition.requestBodyContentType) {
              config.headers!['Content-Type'] = definition.requestBodyContentType;
              if (validatedArgs.requestBody) {
                  config.data = validatedArgs.requestBody;
              }
          }
  
          // Make the request
          const response = await axios(config);
          
          return {
              content: [
                  {
                      type: 'text',
                      text: JSON.stringify(response.data, null, 2)
                  }
              ]
          };
  
      } catch (error: any) {
          if (error instanceof ZodError) {
              return {
                  content: [{
                      type: 'text',
                      text: `Validation error: ${error.message}`
                  }]
              };
          }
          
          if (axios.isAxiosError(error)) {
              return {
                  content: [{
                      type: 'text',
                      text: formatApiError(error)
                  }]
              };
          }
  
          return {
              content: [{
                  type: 'text',
                  text: `Unexpected error: ${error.message}`
              }]
          };
      }
  }

• src/index.ts:100-109 (registration)

  Registration of the tool in toolDefinitionMap, defining its metadata, input schema, API endpoint details (GET /v2/data-privacy/data-for-email-address), parameters (emailAddress and cursor as query params), and security (basicAuth). This entry enables the tool to be listed and dispatched.

  ["getv2dataprivacydataforemailaddress", {
    name: "getv2dataprivacydataforemailaddress",
    description: `Activities for an email address (GDPR helper)`,
    inputSchema: {"type":"object","properties":{"emailAddress":{"type":"string","format":"email"},"cursor":{"type":"string"}},"required":["emailAddress"]},
    method: "get",
    pathTemplate: "/v2/data-privacy/data-for-email-address",
    executionParameters: [{"name":"emailAddress","in":"query"},{"name":"cursor","in":"query"}],
    requestBodyContentType: undefined,
    securityRequirements: [{"basicAuth":[]}]
  }],

• src/index.ts:103-103 (schema)

  JSON Schema for tool input validation: requires 'emailAddress' (email format), optional 'cursor' (string). Used to generate Zod schema for runtime validation.

  inputSchema: {"type":"object","properties":{"emailAddress":{"type":"string","format":"email"},"cursor":{"type":"string"}},"required":["emailAddress"]},

• src/index.ts:143-151 (handler)

  MCP server request handler for CallToolRequestSchema that dispatches to the specific tool by looking up in toolDefinitionMap and calling executeApiTool.

  server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest): Promise<CallToolResult> => {
    const { name: toolName, arguments: toolArgs } = request.params;
    const toolDefinition = toolDefinitionMap.get(toolName);
    if (!toolDefinition) {
      console.error(`Error: Unknown tool requested: ${toolName}`);
      return { content: [{ type: "text", text: `Error: Unknown tool requested: ${toolName}` }] };
    }
    return await executeApiTool(toolName, toolDefinition, toolArgs ?? {}, securitySchemes);
  });

• src/index.ts:462-477 (helper)

  Helper function to convert the tool's JSON inputSchema to a Zod schema for validation in the handler.

  function getZodSchemaFromJsonSchema(jsonSchema: any, toolName: string): z.ZodTypeAny {
      if (typeof jsonSchema !== 'object' || jsonSchema === null) { 
          return z.object({}).passthrough(); 
      }
      try {
          const zodSchemaString = jsonSchemaToZod(jsonSchema);
          const zodSchema = eval(zodSchemaString);
          if (typeof zodSchema?.parse !== 'function') { 
              throw new Error('Eval did not produce a valid Zod schema.'); 
          }
          return zodSchema as z.ZodTypeAny;
      } catch (err: any) {
          console.error(`Failed to generate/evaluate Zod schema for '${toolName}':`, err);
          return z.object({}).passthrough();
      }
  }