UpdateLocalDefinitions

Instructions

Implementation Reference

• src/handlers/class/high/handleUpdateLocalDefinitions.ts:14-42 (schema)

  Tool definition (schema) for UpdateLocalDefinitions — defines name, description, inputSchema with class_name, definitions_code, transport_request, activate_on_update.

  export const TOOL_DEFINITION = {
    name: 'UpdateLocalDefinitions',
    available_in: ['onprem', 'cloud', 'legacy'] as const,
    description:
      'Update local definitions in an ABAP class (definitions include). Manages lock, check, update, unlock, and optional activation.',
    inputSchema: {
      type: 'object',
      properties: {
        class_name: {
          type: 'string',
          description: 'Parent class name (e.g., ZCL_MY_CLASS).',
        },
        definitions_code: {
          type: 'string',
          description: 'Updated source code for local definitions.',
        },
        transport_request: {
          type: 'string',
          description: 'Transport request number.',
        },
        activate_on_update: {
          type: 'boolean',
          description: 'Activate parent class after updating. Default: false',
          default: false,
        },
      },
      required: ['class_name', 'definitions_code'],
    },
  } as const;

• src/handlers/class/high/handleUpdateLocalDefinitions.ts:44-49 (helper)

  TypeScript interface UpdateLocalDefinitionsArgs for the tool's input arguments.

  interface UpdateLocalDefinitionsArgs {
    class_name: string;
    definitions_code: string;
    transport_request?: string;
    activate_on_update?: boolean;
  }

• src/handlers/class/high/handleUpdateLocalDefinitions.ts:51-129 (handler)

  Main handler function handleUpdateLocalDefinitions — validates inputs, creates ADT client, calls client.getLocalDefinitions().update(), handles errors, returns response.

  export async function handleUpdateLocalDefinitions(
    context: HandlerContext,
    args: UpdateLocalDefinitionsArgs,
  ) {
    const { connection, logger } = context;
    try {
      const {
        class_name,
        definitions_code,
        transport_request,
        activate_on_update = false,
      } = args as UpdateLocalDefinitionsArgs;
  
      if (!class_name || !definitions_code) {
        return return_error(
          new Error('class_name and definitions_code are required'),
        );
      }
  
      const client = createAdtClient(connection, logger);
      const className = class_name.toUpperCase();
  
      logger?.info(`Updating local definitions for ${className}`);
  
      try {
        const localDefinitions = client.getLocalDefinitions();
        const updateResult = await localDefinitions.update(
          {
            className,
            definitionsCode: definitions_code,
            transportRequest: transport_request,
          },
          { activateOnUpdate: activate_on_update },
        );
  
        if (!updateResult) {
          throw new Error(`Update did not return a result for ${className}`);
        }
  
        logger?.info(
          `✅ UpdateLocalDefinitions completed successfully: ${className}`,
        );
  
        return return_response({
          data: JSON.stringify(
            {
              success: true,
              class_name: className,
              transport_request: transport_request || null,
              activated: activate_on_update,
              message: `Local definitions updated successfully in ${className}.`,
            },
            null,
            2,
          ),
        } as AxiosResponse);
      } catch (error: any) {
        logger?.error(
          `Error updating local definitions for ${className}: ${error?.message || error}`,
        );
  
        const detailedError = extractAdtErrorMessage(
          error,
          `Failed to update local definitions in ${className}`,
        );
        let errorMessage = `Failed to update local definitions: ${detailedError}`;
  
        if (error.response?.status === 404) {
          errorMessage = `Local definitions for ${className} not found.`;
        } else if (error.response?.status === 423) {
          errorMessage = `Class ${className} is locked by another user.`;
        }
  
        return return_error(new Error(errorMessage));
      }
    } catch (error: any) {
      return return_error(error);
    }
  }

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:94-97 (registration)

  Import of handleUpdateLocalDefinitions and its TOOL_DEFINITION from the handler file, aliased as UpdateLocalDefinitions_Tool.

  import {
    handleUpdateLocalDefinitions,
    TOOL_DEFINITION as UpdateLocalDefinitions_Tool,
  } from '../../../handlers/class/high/handleUpdateLocalDefinitions';

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:857-860 (registration)

  Registration of UpdateLocalDefinitions tool in the HighLevelHandlersGroup with its tool definition and wrapped handler (withContext).

  {
    toolDefinition: UpdateLocalDefinitions_Tool,
    handler: withContext(handleUpdateLocalDefinitions),
  },