GraphQL mit ABAP Cloud: API-Alternativen zu OData

# Client fragt exakt die benötigten Felder an
query GetOrder {
  order(id: "4711") {
    orderId
    customer {
      name
      email
    }
    items {
      product {
        name
        price
      }
      quantity
    }
    totalAmount
  }
}

┌─────────────────────────────────────────────────────────┐
│                      Client (Web/Mobile)                 │
│                           │                              │
│                    GraphQL Query                         │
│                           ▼                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │           GraphQL Gateway (BTP)                  │    │
│  │           Node.js + Apollo Server                │    │
│  └─────────────────────────────────────────────────┘    │
│                           │                              │
│                   OData Requests                         │
│                           ▼                              │
│  ┌─────────────────────────────────────────────────┐    │
│  │           ABAP Cloud (RAP Services)              │    │
│  │           OData V4 Endpoints                     │    │
│  └─────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────┘

// srv/graphql-gateway.js (CAP/Node.js auf BTP)
const { ApolloServer, gql } = require('apollo-server-express');
const axios = require('axios');

// GraphQL Schema Definition
const typeDefs = gql`
  type Order {
    orderId: ID!
    customerId: String
    customer: Customer
    totalAmount: Float
    currency: String
    items: [OrderItem]
  }

  type Customer {
    customerId: ID!
    name: String
    email: String
  }

  type OrderItem {
    itemId: ID!
    productId: String
    quantity: Int
    product: Product
  }

  type Product {
    productId: ID!
    name: String
    price: Float
  }

  type Query {
    order(id: ID!): Order
    orders(top: Int, skip: Int): [Order]
    customer(id: ID!): Customer
  }
`;

// Resolver: GraphQL -> OData Mapping
const resolvers = {
  Query: {
    order: async (_, { id }, { dataSources }) => {
      // OData-Request an ABAP Cloud
      const response = await dataSources.abapAPI.get(
        `/sap/opu/odata4/sap/zorderservice/Orders('${id}')`
      );
      return response.data;
    },
    orders: async (_, { top = 10, skip = 0 }, { dataSources }) => {
      const response = await dataSources.abapAPI.get(
        `/sap/opu/odata4/sap/zorderservice/Orders?$top=${top}&$skip=${skip}`
      );
      return response.data.value;
    }
  },
  Order: {
    // Resolver für verschachtelte Daten
    customer: async (order, _, { dataSources }) => {
      const response = await dataSources.abapAPI.get(
        `/sap/opu/odata4/sap/zorderservice/Customers('${order.customerId}')`
      );
      return response.data;
    },
    items: async (order, _, { dataSources }) => {
      const response = await dataSources.abapAPI.get(
        `/sap/opu/odata4/sap/zorderservice/Orders('${order.orderId}')/Items`
      );
      return response.data.value;
    }
  }
};

-- CDS View Entity für Orders
@AccessControl.authorizationCheck: #CHECK
@EndUserText.label: 'Order'
define view entity Z_I_Order
  as select from zorder
  association [1..1] to Z_I_Customer as _Customer
    on $projection.CustomerId = _Customer.CustomerId
  association [0..*] to Z_I_OrderItem as _Items
    on $projection.OrderId = _Items.OrderId
{
  key order_id     as OrderId,
      customer_id  as CustomerId,
      total_amount as TotalAmount,
      currency     as Currency,

      _Customer,
      _Items
}

-- Service Definition
@EndUserText.label: 'Order Service'
define service Z_SD_Order {
  expose Z_C_Order as Orders;
  expose Z_C_Customer as Customers;
  expose Z_C_OrderItem as OrderItems;
}

CLASS zcl_graphql_handler DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_http_service_extension.

  PRIVATE SECTION.
    METHODS parse_query
      IMPORTING iv_query  TYPE string
      EXPORTING ev_entity TYPE string
                et_fields TYPE string_table.

    METHODS execute_query
      IMPORTING iv_entity TYPE string
                it_fields TYPE string_table
      RETURNING VALUE(rv_json) TYPE string.
ENDCLASS.

CLASS zcl_graphql_handler IMPLEMENTATION.

  METHOD if_http_service_extension~handle_request.
    DATA: lv_body   TYPE string,
          lv_entity TYPE string,
          lt_fields TYPE string_table,
          lv_result TYPE string.

    " Request Body lesen (vereinfachtes GraphQL-Parsing)
    lv_body = request->get_text( ).

    " Query parsen (stark vereinfacht)
    parse_query(
      EXPORTING iv_query  = lv_body
      IMPORTING ev_entity = lv_entity
                et_fields = lt_fields ).

    " Daten abfragen
    lv_result = execute_query(
      iv_entity = lv_entity
      it_fields = lt_fields ).

    " Response
    response->set_text( lv_result ).
    response->set_header_field(
      i_name  = 'Content-Type'
      i_value = 'application/json' ).
  ENDMETHOD.

  METHOD parse_query.
    " Vereinfachtes Parsing - produktiv würde ein Parser benötigt
    " Beispiel: { orders { orderId totalAmount } }
    " ...
  ENDMETHOD.

  METHOD execute_query.
    " Dynamische Feldauswahl basierend auf GraphQL-Query
    " In der Praxis: CDS View mit dynamischer Projektion
    " ...
  ENDMETHOD.

ENDCLASS.

query GetOrderWithDetails {
  order(id: "4711") {
    orderId
    totalAmount
    customer {
      name
      email
    }
    items {
      quantity
      product {
        name
        price
      }
    }
  }
}

GET /Orders('4711')?$select=OrderId,TotalAmount
    &$expand=Customer($select=Name,Email),
             Items($select=Quantity;$expand=Product($select=Name,Price))

" OData-Request mit $expand
DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination(
  i_destination = cl_http_destination_provider=>create_by_comm_arrangement(
    comm_scenario  = 'Z_OUTBOUND_ODATA'
    service_id     = 'Z_ODATA_SERVICE' ) ).

DATA(lo_request) = lo_client->get_http_request( ).
lo_request->set_uri_path(
  '/sap/opu/odata4/sap/zorderservice/Orders(''4711'')' &&
  '?$expand=Customer,Items($expand=Product)' ).

DATA(lo_response) = lo_client->execute( i_method = if_web_http_client=>get ).
DATA(lv_json) = lo_response->get_text( ).

" JSON parsen
/ui2/cl_json=>deserialize(
  EXPORTING json = lv_json
  CHANGING  data = ls_order ).

CLASS zcl_graphql_client DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS execute_query
      IMPORTING iv_query      TYPE string
                iv_variables  TYPE string OPTIONAL
      RETURNING VALUE(rv_response) TYPE string
      RAISING   cx_web_http_client_error.
ENDCLASS.

CLASS zcl_graphql_client IMPLEMENTATION.

  METHOD execute_query.
    " GraphQL-Request bauen
    DATA(lv_body) = |\{"query": "{ iv_query }"|.
    IF iv_variables IS NOT INITIAL.
      lv_body = lv_body && |, "variables": { iv_variables }|.
    ENDIF.
    lv_body = lv_body && |\}|.

    " HTTP Client erstellen
    DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination(
      i_destination = cl_http_destination_provider=>create_by_comm_arrangement(
        comm_scenario  = 'Z_GRAPHQL_OUTBOUND'
        service_id     = 'GRAPHQL_API' ) ).

    DATA(lo_request) = lo_client->get_http_request( ).
    lo_request->set_uri_path( '/graphql' ).
    lo_request->set_header_field(
      i_name  = 'Content-Type'
      i_value = 'application/json' ).
    lo_request->set_text( lv_body ).

    " POST-Request ausführen
    DATA(lo_response) = lo_client->execute( i_method = if_web_http_client=>post ).
    rv_response = lo_response->get_text( ).

    lo_client->close( ).
  ENDMETHOD.

ENDCLASS.

DATA(lo_gql) = NEW zcl_graphql_client( ).

DATA(lv_query) = |query \{ user(id: "123") \{ name email \} \}|.

TRY.
    DATA(lv_result) = lo_gql->execute_query( lv_query ).
    " JSON-Response verarbeiten...
  CATCH cx_web_http_client_error INTO DATA(lx_error).
    " Fehlerbehandlung
ENDTRY.