GetDataElement

Instructions

Implementation Reference

• src/handlers/data_element/high/handleGetDataElement.ts:50-126 (handler)

  Main handler function for GetDataElement tool. Uses AdtClient.getDataElement().read() to retrieve a data element by name, supporting both 'active' and 'inactive' versions. Validates input, calls the ADT client, and returns the data element definition.

  export async function handleGetDataElement(
    context: HandlerContext,
    args: GetDataElementArgs,
  ) {
    const { connection, logger } = context;
    try {
      const { data_element_name, version = 'active' } =
        args as GetDataElementArgs;
  
      // Validation
      if (!data_element_name) {
        return return_error(new Error('data_element_name is required'));
      }
  
      const client = createAdtClient(connection, logger);
      const dataElementName = data_element_name.toUpperCase();
  
      logger?.info(
        `Reading data element ${dataElementName}, version: ${version}`,
      );
  
      try {
        // Read data element using AdtClient
        const dataElementObject = client.getDataElement();
        const readResult = await dataElementObject.read(
          { dataElementName },
          version as 'active' | 'inactive',
        );
  
        if (!readResult || !readResult.readResult) {
          throw new Error(`Data element ${dataElementName} not found`);
        }
  
        // Extract data from read result
        const dataElementData =
          typeof readResult.readResult.data === 'string'
            ? readResult.readResult.data
            : JSON.stringify(readResult.readResult.data);
  
        logger?.info(
          `✅ GetDataElement completed successfully: ${dataElementName}`,
        );
  
        return return_response({
          data: JSON.stringify(
            {
              success: true,
              data_element_name: dataElementName,
              version,
              data_element_data: dataElementData,
              status: readResult.readResult.status,
              status_text: readResult.readResult.statusText,
            },
            null,
            2,
          ),
        } as AxiosResponse);
      } catch (error: any) {
        logger?.error(
          `Error reading data element ${dataElementName}: ${error?.message || error}`,
        );
  
        // Parse error message
        let errorMessage = `Failed to read data element: ${error.message || String(error)}`;
  
        if (error.response?.status === 404) {
          errorMessage = `Data element ${dataElementName} not found.`;
        } else if (error.response?.status === 423) {
          errorMessage = `Data element ${dataElementName} is locked by another user.`;
        }
  
        return return_error(new Error(errorMessage));
      }
    } catch (error: any) {
      return return_error(error);
    }
  }

• src/handlers/data_element/high/handleGetDataElement.ts:16-38 (schema)

  Tool definition (TOOL_DEFINITION) including name 'GetDataElement', availability ('onprem','cloud'), description, and inputSchema with required 'data_element_name' string and optional 'version' enum ('active'/'inactive').

  export const TOOL_DEFINITION = {
    name: 'GetDataElement',
    available_in: ['onprem', 'cloud'] as const,
    description:
      'Retrieve ABAP data element definition. Supports reading active or inactive version.',
    inputSchema: {
      type: 'object',
      properties: {
        data_element_name: {
          type: 'string',
          description: 'Data element name (e.g., Z_MY_DATA_ELEMENT).',
        },
        version: {
          type: 'string',
          enum: ['active', 'inactive'],
          description:
            'Version to read: "active" (default) for deployed version, "inactive" for modified but not activated version.',
          default: 'active',
        },
      },
      required: ['data_element_name'],
    },
  } as const;

• src/handlers/data_element/high/handleGetDataElement.ts:40-43 (schema)

  TypeScript interface GetDataElementArgs defining the structure of input arguments (data_element_name: string, version?: 'active' | 'inactive').

  interface GetDataElementArgs {
    data_element_name: string;
    version?: 'active' | 'inactive';
  }

• src/handlers/compact/high/compactRouter.ts:113-118 (registration)

  Registration of handleGetDataElement as the 'get' handler for DATA_ELEMENT in the compact router map, enabling dispatch for the GetDataElement tool.

  DATA_ELEMENT: {
    create: handleCreateDataElement as unknown as CompactHandler,
    get: handleGetDataElement as unknown as CompactHandler,
    update: handleUpdateDataElement as unknown as CompactHandler,
    delete: handleDeleteDataElement as unknown as CompactHandler,
  },

• src/handlers/compact/high/compactRouter.ts:29-29 (registration)

  Import statement pulling handleGetDataElement into the compact router for registration.

  import { handleGetDataElement } from '../../data_element/high/handleGetDataElement';