ActivateView

Instructions

Implementation Reference

• src/handlers/view/low/handleActivateView.ts:65-180 (handler)

  Main handler function for the ActivateView MCP tool. Uses AdtClient to activate a CDS view, parses the activation response, and returns success/error details with warnings and errors.

  export async function handleActivateView(
    context: HandlerContext,
    args: ActivateViewArgs,
  ) {
    const { connection, logger } = context;
    try {
      const { view_name, session_id, session_state } = args as ActivateViewArgs;
  
      // Validation
      if (!view_name) {
        return return_error(new Error('view_name is required'));
      }
  
      const client = createAdtClient(connection, logger);
  
      // Restore session state if provided
      if (session_id && session_state) {
        await restoreSessionInConnection(connection, session_id, session_state);
      } else {
        // Ensure connection is established
      }
  
      const viewName = view_name.toUpperCase();
  
      logger?.info(`Starting view activation: ${viewName}`);
  
      try {
        // Activate view
        const activateState = await client
          .getView()
          .activate({ viewName: viewName });
        const response = activateState.activateResult;
  
        if (!response) {
          throw new Error(
            `Activation did not return a response for view ${viewName}`,
          );
        }
  
        // Parse activation response
        const activationResult = parseActivationResponse(response.data);
        const success = activationResult.activated && activationResult.checked;
  
        // Get updated session state after activation
  
        logger?.info(`✅ ActivateView completed: ${viewName}`);
        logger?.info(
          `   Activated: ${activationResult.activated}, Checked: ${activationResult.checked}`,
        );
        logger?.info(`   Messages: ${activationResult.messages.length}`);
  
        return return_response({
          data: JSON.stringify(
            {
              success,
              view_name: viewName,
              activation: {
                activated: activationResult.activated,
                checked: activationResult.checked,
                generated: activationResult.generated,
              },
              messages: activationResult.messages,
              warnings: activationResult.messages.filter(
                (m) => m.type === 'warning' || m.type === 'W',
              ),
              errors: activationResult.messages.filter(
                (m) => m.type === 'error' || m.type === 'E',
              ),
              session_id: session_id || null,
              session_state: null, // Session state management is now handled by auth-broker,
              message: success
                ? `View ${viewName} activated successfully`
                : `View ${viewName} activation completed with ${activationResult.messages.length} message(s)`,
            },
            null,
            2,
          ),
        } as AxiosResponse);
      } catch (error: any) {
        logger?.error(
          `Error activating view ${viewName}: ${error?.message || error}`,
        );
  
        // Parse error message
        let errorMessage = `Failed to activate view: ${error.message || String(error)}`;
  
        if (error.response?.status === 404) {
          errorMessage = `View ${viewName} not found.`;
        } else if (
          error.response?.data &&
          typeof error.response.data === 'string'
        ) {
          try {
            const { XMLParser } = require('fast-xml-parser');
            const parser = new XMLParser({
              ignoreAttributes: false,
              attributeNamePrefix: '@_',
            });
            const errorData = parser.parse(error.response.data);
            const errorMsg =
              errorData['exc:exception']?.message?.['#text'] ||
              errorData['exc:exception']?.message;
            if (errorMsg) {
              errorMessage = `SAP Error: ${errorMsg}`;
            }
          } catch (_parseError) {
            // Ignore parse errors
          }
        }
  
        return return_error(new Error(errorMessage));
      }
    } catch (error: any) {
      return return_error(error);
    }
  }

• src/handlers/view/low/handleActivateView.ts:50-58 (schema)

  TypeScript interface defining the input arguments for the ActivateView handler (view_name required, optional session_id and session_state).

  interface ActivateViewArgs {
    view_name: string;
    session_id?: string;
    session_state?: {
      cookies?: string;
      csrf_token?: string;
      cookie_store?: Record<string, string>;
    };
  }

• src/handlers/view/low/handleActivateView.ts:18-48 (schema)

  Tool definition/schema for the low-level ActivateViewLow tool, containing inputSchema with view_name (required), session_id, and session_state fields.

  export const TOOL_DEFINITION = {
    name: 'ActivateViewLow',
    available_in: ['onprem', 'cloud', 'legacy'] as const,
    description:
      'Operation: Activate, Create, Update. Subject: View. Will be useful for activating, creating, or updating view. [low-level] Activate an ABAP view (CDS view). Returns activation status and any warnings/errors. Can use session_id and session_state from GetSession to maintain the same session.',
    inputSchema: {
      type: 'object',
      properties: {
        view_name: {
          type: 'string',
          description: 'View name (e.g., ZVW_MY_VIEW).',
        },
        session_id: {
          type: 'string',
          description:
            'Session ID from GetSession. If not provided, a new session will be created.',
        },
        session_state: {
          type: 'object',
          description:
            'Session state from GetSession (cookies, csrf_token, cookie_store). Required if session_id is provided.',
          properties: {
            cookies: { type: 'string' },
            csrf_token: { type: 'string' },
            cookie_store: { type: 'object' },
          },
        },
      },
      required: ['view_name'],
    },
  } as const;

• src/lib/handlers/groups/HighLevelHandlersGroup.ts:539-547 (registration)

  Registration of the ActivateView tool in the HighLevelHandlersGroup, which reuses the low-level handler but overrides the name to 'ActivateView' and provides a high-level description.

  {
    toolDefinition: {
      ...ActivateView_Tool,
      name: 'ActivateView',
      description:
        'Activate a CDS view. Use after CreateView or UpdateView if the object remains inactive.',
    },
    handler: withContext(handleActivateView),
  },