`.
**Usage with `uri`**
```js
{
uri: String,
mcApiProxyTarget?: ApiProxyTarget,
payload?: Object | String
}
```
- `uri` can be relative or absolute. It gets passed to [`sdk-client`](https://commercetools.github.io/nodejs/sdk/api/sdkClient.html) as-is
This approach must be used when querying something other than the CTP API. In case the CTP API is queried it is recommended to use `service` and `options` since that is easier to test. It is totally valid to provide `uri` only as well though.
When both, `uri` and `options` (or `service`) are present, the `uri` takes precedence.
**Usage with `service` and `options`**
```js
{
service: String,
options: Object,
mcApiProxyTarget?: ApiProxyTarget,
payload?: Object | String
}
```
Before using the `sdk-client` the `sdk` middleware combines `service` and `options` using `api-request-builder`'s `parse` method to form a `uri`. It then makes the exact same request as when specifying `uri` directly.
The supported `options` can be found in the `api-request-builder`'s documentation under the [Declarative Usage](https://commercetools.github.io/nodejs/sdk/api/apiRequestBuilder.html#declarative-usage) section.
## Action creators for external API usage
By default, all requests with the SDK are configured to be sent to the MC API.
However, Custom Applications using the [Proxy to external API](https://docs.commercetools.com/merchant-center-customizations/concepts/integrate-with-your-own-api) need to configure the request a bit differently, and send additional headers.
To make it easier to make requests to the proxy endpoint using the SDK, there is a new action creator wrapper that comes with built-in configuration options.
The exported action creators have a new export `forwardTo`, which is an object containing wrappers around the normal action creators.
```js
actions.forwardTo.get(options);
actions.forwardTo.del(options);
actions.forwardTo.head(options);
actions.forwardTo.post(options);
```
The options for the action creators are the same as the **Usage with `uri`**, except that the `uri` value needs to be the URL to the external API (see `X-Forward-To` header).
The `forwardTo` action creators additionally set the following headers:
- `Accept-version`
- `X-Forward-To`
- `X-Forward-To-Audience-Policy`
For more information, check the [Proxy to external API](https://docs.commercetools.com/merchant-center-customizations/concepts/integrate-with-your-own-api) documentation.
## Error handling
Failed requests will result in a rejected promise. The `sdk-client`'s error handling applies, so network errors and CTP API errors on the content itself result in a rejected promise.
The `sdk` package does not provide any error handling out of the box. It's the application's responsibility to handle errors (e.g. show a notification, track the error).
The Merchant Center has a `handleActionError` function which is what we currently use for error handling. It logs the error to the tracking tool (Sentry) and shows a notification to the client. This should be used whenever a more special error handling is not necessary.
## Example
```js
import { actions as sdkActions } from '@commercetools-frontend/sdk';
const fetchProductById = (productId) =>
sdkActions.get({
service: 'products',
options: { id: productId },
});
```
```js
import * as globalActions from '@commercetools-frontend/actions-global';
class ProductPage extends React.Component {
state = { product: null };
componentDidMount() {
this.props.fetchProductById(this.props.productId).then(
(product) => {
this.setState({ product });
},
(error) => {
this.props.onActionError(error, 'ProductPage/fetchProductById');
}
);
}
render() {
if (!this.state.product) return ;
return {JSON.stringify(this.state.product)}
;
}
}
// and finally we need to pass the bound action creator to the component using plain old redux
export default connect(null, {
fetchProductById: productsActions.fetchProductById,
onActionError: globalActions.handleActionError,
})(ProductPage);
```