ValidateServiceBinding

Instructions

Implementation Reference

• src/handlers/service_binding/high/handleValidateServiceBinding.ts:47-91 (handler)

  The main handler function that validates a service binding by calling the ADT validation endpoint. It accepts service_binding_name, service_definition_name, and optional parameters, then returns parsed validation results.

  export async function handleValidateServiceBinding(
    context: HandlerContext,
    args: ValidateServiceBindingArgs,
  ) {
    const { connection, logger } = context;
  
    try {
      if (!args?.service_binding_name) {
        throw new Error('service_binding_name is required');
      }
      if (!args?.service_definition_name) {
        throw new Error('service_definition_name is required');
      }
  
      const serviceBindingName = args.service_binding_name.trim().toUpperCase();
      const client = createAdtClient(connection, logger);
      const response = await client.getServiceBinding().validateServiceBinding({
        objname: serviceBindingName,
        serviceDefinition: args.service_definition_name.trim().toUpperCase(),
        serviceBindingVersion: args.service_binding_version?.trim() || undefined,
        description: args.description?.trim() || undefined,
        package: args.package_name?.trim().toUpperCase() || undefined,
      });
  
      return return_response({
        data: JSON.stringify(
          {
            success: true,
            service_binding_name: serviceBindingName,
            status: response.status,
            payload: parseServiceBindingPayload(response.data, 'xml'),
          },
          null,
          2,
        ),
        status: response.status,
        statusText: response.statusText,
        headers: response.headers,
        config: response.config,
      });
    } catch (error: any) {
      logger?.error('Error validating service binding:', error);
      return return_error(error);
    }
  }

• src/handlers/service_binding/high/handleValidateServiceBinding.ts:6-37 (schema)

  The tool definition (input schema, description, available environments) for ValidateServiceBinding. Specifies required fields: service_binding_name and service_definition_name.

  export const TOOL_DEFINITION = {
    name: 'ValidateServiceBinding',
    available_in: ['onprem', 'cloud'] as const,
    description:
      'Validate service binding parameters (name, service definition, package, version) via ADT validation endpoint.',
    inputSchema: {
      type: 'object',
      properties: {
        service_binding_name: {
          type: 'string',
          description: 'Service binding name to validate.',
        },
        description: {
          type: 'string',
          description: 'Optional description used during validation.',
        },
        service_definition_name: {
          type: 'string',
          description: 'Service definition linked to binding.',
        },
        package_name: {
          type: 'string',
          description: 'ABAP package for the binding.',
        },
        service_binding_version: {
          type: 'string',
          description: 'Service binding version (for example: 1.0).',
        },
      },
      required: ['service_binding_name', 'service_definition_name'],
    },
  } as const;

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:753-756 (registration)

  Registration of ValidateServiceBinding in the HighLevelHandlersGroup, mapping the tool definition to its handler with context wrapper.

  {
    toolDefinition: ValidateServiceBinding_Tool,
    handler: withContext(handleValidateServiceBinding),
  },

• src/handlers/service_binding/high/serviceBindingPayloadUtils.ts:17-54 (helper)

  Helper utility that parses the XML/JSON/plain response payload from the ADT validation endpoint into a structured object.

  export function parseServiceBindingPayload(
    payload: unknown,
    format: ServiceBindingResponseFormat,
  ): unknown {
    if (format === 'plain') {
      return payload;
    }
  
    if (format === 'json') {
      if (typeof payload === 'string') {
        try {
          return JSON.parse(payload);
        } catch {
          return payload;
        }
      }
      return payload;
    }
  
    if (typeof payload !== 'string') {
      return payload;
    }
  
    const trimmed = payload.trim();
    if (!trimmed.startsWith('<')) {
      return payload;
    }
  
    try {
      const parser = new XMLParser({
        ignoreAttributes: false,
        attributeNamePrefix: '',
      });
      return parser.parse(trimmed);
    } catch {
      return payload;
    }
  }

• src/handlers/compact/high/handleHandlerServiceBindingValidate.ts:21-26 (handler)

  Compact handler that delegates directly to handleValidateServiceBinding, serving as an alternative entry point.

  export async function handleHandlerServiceBindingValidate(
    context: HandlerContext,
    args: HandlerServiceBindingValidateArgs,
  ) {
    return handleValidateServiceBinding(context, args);
  }