Using multipart/form Data

If you have set "contentType" to "multipart/form-data", the Call REST action interprets your request "body" object as the form parts. Each property of the body object is a form part, which is a key-value pair with its own content type and disposition.

If "filePath" is also set, it is added as an additional part using the lookup of common file extension types.

If "filePath" is also set, it is added as an additional part using the sample simple file extension type association. The name of this part is "file", or can be specified using "filePartName".

You may optionally override the file type by using "fileContentType" for the file part.

For more about working with the multipart/form-data format, refer to this Oracle blog, Consuming REST APIs in VB - multipart/form-data.

Parameters Typically Required per Endpoint Type

These are the typically required parameters for each endpoint type:

• POST:
  • body parameter is set to the variable containing the new record's data.
  • uriParams parameter is used to provide any required input parameters.

  Here's an example POST endpoint call:

        const callRestCreateIncident = await Actions.callRest(context, {
          endpoint: 'fixitfast/putIncident',
          body: $variables.incidentPayload ,
          uriParams: {
            id: $constants.incidentId,
          },
        });

• GET:
  • uriParams parameter is used to provide any required input parameters, such as an ID input parameter to get a single record.

    Here's an example of a GET endpoint call to get a single record. The empIDToGet_ip variable is an input parameter that passes the record's ID to the action chain that contains this Call REST call:

          const getEmployeeResult = await Actions.callRest(context, {
            endpoint: 'businessObjects/get_Employee',
            uriParams: {
              'Employee_Id': empIDToGet_ip,
            },
          });

• DELETE:
  • uriParams parameter is used to provide the ID of the record to delete.

    Here's an example of a DELETE endpoint call to delete a record. The empIDToDelete_ip variable is an input parameter that passes the record's ID to the action chain that contains this Call REST call:

          const callRestBusinessObjectsDeleteEmployeeResult = await Actions.callRest(context, {
            endpoint: 'businessObjects/delete_Employee',
            uriParams: {
              'Employee_Id': empIDToDelete_ip,
            },
          });

• PATCH:
  • body parameter is set to the variable containing the record with the updated data.
  • uriParams parameter is used to provide the ID of the record to update.

  Here's an example PATCH endpoint call:

        const updateEmployeeResult = await Actions.callRest(context, {
          endpoint: 'businessObjects/update_Employee',
          uriParams: {
            'Employee_Id': $variables.empID_pv,
          },
          body: $variables.EmpUpdatedData_pv,
        });

Service Definitions

If your service connection details are static, the details, such as the server, path, and schema of the request and response, are stored in the openapi3.json file for the service connection.

To view or edit a service's definition, select the service connection in the Services pane, then open the Source tab. The editor uses the OpenAPI3 specification and JSON format.

Description of the illustration jsac-service-connection-source-tab.jpg

Transforms

The requestTransformOptions, requestTransformFunctions, and responseTransformFunctions can be used to modify the request and response. Some built-in service endpoints have built-in transform functions for 'sort', 'filter', 'paginate', and 'select', so options for these transform functions can be defined using the same name via the requestTransformOptions property. For third party services, the options set are based on the type of transform functions supported.

When using the Rest Action, the transform names have no semantic meaning and all request and response transforms are called.

Request and response transform functions have the following signatures.

/**
 * configuration: {
 *  url:
 *   initConfig: {
 *     method: // string with http method
 *     body: // request body, if any
 *     credentials: // string see (fetch) Request
 *     headers: // object, map of strings
 *   }
 * },
 *
 * options: provided by the application
 *
 * context: an empty object, which exists for the
 *   lifetime of one REST call, a set of 
 *   transforms share this.
 **/
 
mytransform(configuration, options, context)

/**
 * response: { body, headers }
 *
 * context: an empty object, see "Request transforms"
 *
 */
myresponsetransform(response, context);

/**
 * {
 *  response: The (fetch) Response object. Note that the body has already
 *     been read, so the functions (ex. json()) cannot be called.
 *
 *  body: the result of the json()/text()/etc.
 * 
 *  transformResults: a map of return values from Response Transforms
 * }
 */

Error Handling and Return Values

If the underlying REST API request returns a status code, the error object is returned for you to handle the error yourself, otherwise an auto-generated error notification is shown.

The object returned by the Call REST action returns these results:

{
  body {},
  error: null,
  headers: Headers {},
  message: {summary: ‘ ’},  
  ok: true,
  status: 200
  statusText: "OK",
}

{
  body: null,
  error: null,
  headers: Headers {},
  message: {summary: ‘<error summary>’},  
  ok: false,
  status: <status number>,
  statusText: ‘<error type>’
}