@atlaskit/link-client-extension 8.0.0 → 8.0.1

package/dist/es2019/services/use-integration-actions-client/get-agg-url.js

@@ -0,0 +1,28 @@
+import { getBaseUrl } from '@atlaskit/linking-common/get-base-url';
+import { EXECUTE_INTEGRATION_ACTION_OPERATION_NAME } from './constants';
+const EDGE_PROXY_AGG_PATH = '/gateway/api/graphql';
+
+/**
+ * AGG endpoint for the CardClient's environment.
+ * - No envKey (running inside a product): same-origin `/gateway/api/graphql`. On the server there
+ *   is no `window`, so this is relative and requests fail with an `http` error instead of crashing.
+ * - `custom`: `baseUrlOverride` is a full object resolver URL (e.g. a direct service URL for SSR),
+ *   so we can't build an AGG URL from it. Use the relative edge proxy path instead, the same
+ *   fallback `getResolverUrl` uses.
+ * - Other envKeys (e.g. `stg` in examples): the Stargate base URL for that environment + `/graphql`,
+ *   e.g. `https://pug.jira-dev.com/gateway/api/graphql`.
+ * The operation name is added as a query param so requests are easy to identify.
+ */
+export const getAggUrl = envKey => {
+  let graphqlUrl;
+  if (envKey === 'custom') {
+    graphqlUrl = EDGE_PROXY_AGG_PATH;
+  } else if (envKey) {
+    const stargateBaseUrl = getBaseUrl(envKey);
+    graphqlUrl = `${stargateBaseUrl.replace(/\/$/, '')}/graphql`;
+  } else {
+    const origin = getBaseUrl();
+    graphqlUrl = `${origin}${EDGE_PROXY_AGG_PATH}`;
+  }
+  return `${graphqlUrl}?operationName=${EXECUTE_INTEGRATION_ACTION_OPERATION_NAME}`;
+};

package/dist/es2019/services/use-integration-actions-client/index.js

@@ -0,0 +1,84 @@
+import { useCallback, useMemo } from 'react';
+import { request } from '@atlaskit/linking-common/api';
+import { buildRequestHeaders } from './build-request-headers';
+import { EXECUTE_INTEGRATION_ACTION_MUTATION, EXECUTE_INTEGRATION_ACTION_OPERATION_NAME } from './constants';
+import { getAggUrl } from './get-agg-url';
+import { IntegrationActionError } from './integration-action-error';
+import { parseExecuteIntegrationActionResponse } from './parse-execute-integration-action-response';
+// Check the shape rather than `instanceof Response`; `instanceof` checks on errors have caused HOTs before.
+const isResponseLike = value => typeof value === 'object' && value !== null && typeof value.json === 'function';
+const readErrorBody = async response => {
+  try {
+    return await response.json();
+  } catch {
+    return undefined;
+  }
+};
+const toHttpError = (error, statusCode) => new IntegrationActionError('http', error instanceof Error && error.message ? error.message : `Request failed${statusCode ? ` with status ${statusCode}` : ''}`, {
+  statusCode,
+  originalError: error
+});
+/**
+ * useIntegrationActionsClient
+ *
+ * Runs Integrations Service (IS) actions on 3P resources (e.g. listing or adding Google Docs
+ * comments) through the AGG `actions { execute }` mutation. Uses a plain fetch rather than Relay,
+ * so it works in any host that provides a CardClient.
+ *
+ * `executeAction` resolves with the action's `outputs`. It throws an `IntegrationActionError` when:
+ * - the user needs to connect their 3P account (`kind: 'consent-required'`, with `authUrl`)
+ * - IS reports the action failed (`kind: 'operation'`)
+ * - AGG returns GraphQL errors (`kind: 'graphql'`)
+ * - the request fails (`kind: 'http'`)
+ *
+ * Each request sends the AGG metrics attribution header (`atl-attribution`), using
+ * `actionInput.cloudId` as the tenant.
+ *
+ * Call `executeAction` from effects or event handlers, not during render (it doesn't run in SSR).
+ *
+ * @param cardClient used to pick the AGG endpoint for the environment
+ * @param options.product product hosting the Smart Link, for metrics attribution
+ */
+export const useIntegrationActionsClient = (cardClient, {
+  product
+} = {}) => {
+  const aggUrl = useMemo(() => getAggUrl(cardClient === null || cardClient === void 0 ? void 0 : cardClient.envKey), [cardClient === null || cardClient === void 0 ? void 0 : cardClient.envKey]);
+  const executeAction = useCallback(async ({
+    actionTypeKey,
+    filter,
+    actionInput,
+    workspace
+  }) => {
+    let body;
+    try {
+      body = await request('post', aggUrl, {
+        operationName: EXECUTE_INTEGRATION_ACTION_OPERATION_NAME,
+        query: EXECUTE_INTEGRATION_ACTION_MUTATION,
+        variables: {
+          actionTypeKey,
+          filter,
+          actionInput,
+          workspace
+        }
+      }, buildRequestHeaders({
+        cloudId: actionInput === null || actionInput === void 0 ? void 0 : actionInput.cloudId,
+        product
+      }), [200]);
+    } catch (error) {
+      // `request` throws the Response for non-2xx statuses. AGG may still include GraphQL errors.
+      if (isResponseLike(error)) {
+        var _errorBody$errors, _errorBody$data, _errorBody$data$actio;
+        const errorBody = await readErrorBody(error);
+        if (errorBody !== null && errorBody !== void 0 && (_errorBody$errors = errorBody.errors) !== null && _errorBody$errors !== void 0 && _errorBody$errors.length || errorBody !== null && errorBody !== void 0 && (_errorBody$data = errorBody.data) !== null && _errorBody$data !== void 0 && (_errorBody$data$actio = _errorBody$data.actions) !== null && _errorBody$data$actio !== void 0 && _errorBody$data$actio.execute) {
+          return parseExecuteIntegrationActionResponse(errorBody, error.status);
+        }
+        throw toHttpError(undefined, error.status);
+      }
+      throw toHttpError(error);
+    }
+    return parseExecuteIntegrationActionResponse(body, 200);
+  }, [aggUrl, product]);
+  return useMemo(() => ({
+    executeAction
+  }), [executeAction]);
+};

package/dist/es2019/services/use-integration-actions-client/integration-action-error.js

@@ -0,0 +1,21 @@
+/** Thrown by `executeAction` when an action can't be run or fails. */
+export class IntegrationActionError extends Error {
+  /** Set when `kind` is `consent-required`: where the user can connect their 3P account. */
+
+  /** HTTP status, or the status IS reported for the action. */
+
+  /** The underlying error, when the request itself failed. */
+
+  constructor(kind, message, options = {}) {
+    super(message);
+    this.name = 'IntegrationActionError';
+    this.kind = kind;
+    this.authUrl = options.authUrl;
+    this.errorType = options.errorType;
+    this.retryable = options.retryable;
+    this.statusCode = options.statusCode;
+    this.graphQLErrors = options.graphQLErrors;
+    this.operationErrors = options.operationErrors;
+    this.originalError = options.originalError;
+  }
+}

package/dist/es2019/services/use-integration-actions-client/mocks.js

@@ -0,0 +1,85 @@
+/**
+ * Mock AGG `actions { execute }` responses, based on what the ASIMO-5527 spike saw
+ * on staging.
+ */
+
+export const mockExecuteIntegrationActionSuccessResponse = {
+  data: {
+    actions: {
+      execute: {
+        status: 200,
+        outputs: {
+          entities: {
+            comments: [{
+              id: 'comment-1',
+              content: 'Looks good to me',
+              author: {
+                displayName: 'Jane Smith'
+              },
+              createdTime: '2026-10-27T01:00:00.000Z'
+            }]
+          }
+        }
+      }
+    }
+  }
+};
+export const mockAuthUrl = 'https://id.atlassian.com/outboundAuth/start?key=google-drive';
+
+/** IS returns consent errors in `outputs.errors` with HTTP 200 and no GraphQL `errors`. */
+export const mockExecuteIntegrationActionConsentRequiredResponse = {
+  data: {
+    actions: {
+      execute: {
+        status: 401,
+        outputs: {
+          errors: [{
+            message: 'User consent is required to access this integration',
+            statusCode: 401,
+            extensions: {
+              errorType: 'USER_CONSENT_REQUIRED',
+              errorCategory: 'AUTH',
+              retryable: false,
+              authUrl: mockAuthUrl
+            }
+          }]
+        }
+      }
+    }
+  }
+};
+export const mockExecuteIntegrationActionOperationFailureResponse = {
+  data: {
+    actions: {
+      execute: {
+        status: 404,
+        outputs: {
+          errors: [{
+            message: 'File not found',
+            statusCode: 404,
+            extensions: {
+              errorType: 'NOT_FOUND',
+              errorCategory: 'CLIENT',
+              retryable: false
+            }
+          }]
+        }
+      }
+    }
+  }
+};
+export const mockExecuteIntegrationActionGraphQLErrorResponse = {
+  data: {
+    actions: {
+      execute: null
+    }
+  },
+  errors: [{
+    message: 'Action not found for filter',
+    path: ['actions', 'execute'],
+    extensions: {
+      classification: 'DataFetchingException',
+      statusCode: 400
+    }
+  }]
+};

package/dist/es2019/services/use-integration-actions-client/parse-execute-integration-action-response.js

@@ -0,0 +1,148 @@
+import { GENERIC_GRAPHQL_ERROR_MESSAGE, GENERIC_OPERATION_ERROR_MESSAGE, USER_CONSENT_REQUIRED } from './constants';
+import { IntegrationActionError } from './integration-action-error';
+const isRecord = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSuccessStatus = status => status >= 200 && status < 300;
+const getStringExtension = (extensions, key) => {
+  const value = extensions === null || extensions === void 0 ? void 0 : extensions[key];
+  return typeof value === 'string' && value !== '' ? value : undefined;
+};
+
+/**
+ * Returns `authUrl` from the extensions only if it's an absolute `https:` URL, so a malformed or
+ * unsafe value (e.g. `javascript:`) is never handed to the UI to open.
+ */
+const getAuthUrl = extensions => {
+  const value = getStringExtension(extensions, 'authUrl');
+  if (!value) {
+    return undefined;
+  }
+  try {
+    return new URL(value).protocol === 'https:' ? value : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+/** Normalises an entry of `outputs.errors`, which IS doesn't guarantee is well-formed. */
+const toOperationErrorEntry = error => {
+  if (typeof error === 'string') {
+    return {
+      message: error || GENERIC_OPERATION_ERROR_MESSAGE
+    };
+  }
+  if (!isRecord(error)) {
+    return {
+      message: GENERIC_OPERATION_ERROR_MESSAGE
+    };
+  }
+  return {
+    message: typeof error.message === 'string' && error.message !== '' ? error.message : GENERIC_OPERATION_ERROR_MESSAGE,
+    // Values are read with runtime checks below, so the cast doesn't trust their types.
+    ...(isRecord(error.extensions) ? {
+      extensions: error.extensions
+    } : {}),
+    ...(typeof error.statusCode === 'number' ? {
+      statusCode: error.statusCode
+    } : {})
+  };
+};
+
+/** Normalises an entry of the GraphQL `errors` array, which may be malformed. */
+const toGraphQLErrorEntry = error => {
+  if (!isRecord(error)) {
+    return {
+      message: typeof error === 'string' && error ? error : GENERIC_GRAPHQL_ERROR_MESSAGE
+    };
+  }
+  return {
+    message: typeof error.message === 'string' && error.message !== '' ? error.message : GENERIC_GRAPHQL_ERROR_MESSAGE,
+    ...(isRecord(error.extensions) ? {
+      extensions: error.extensions
+    } : {}),
+    ...(Array.isArray(error.path) ? {
+      path: error.path
+    } : {})
+  };
+};
+
+/** A non-empty `outputs.errors` always means the action failed, even if the entries are malformed. */
+const getOperationErrors = outputs => {
+  const errors = isRecord(outputs) ? outputs.errors : undefined;
+  if (!Array.isArray(errors) || errors.length === 0) {
+    return undefined;
+  }
+  return errors.map(toOperationErrorEntry);
+};
+const toOperationError = (operationErrors, status) => {
+  var _error$extensions, _error$statusCode;
+  const consentError = operationErrors.find(error => getStringExtension(error.extensions, 'errorType') === USER_CONSENT_REQUIRED || !!getAuthUrl(error.extensions));
+  const error = consentError !== null && consentError !== void 0 ? consentError : operationErrors[0];
+  const authUrl = getAuthUrl(consentError === null || consentError === void 0 ? void 0 : consentError.extensions);
+  const retryable = (_error$extensions = error.extensions) === null || _error$extensions === void 0 ? void 0 : _error$extensions.retryable;
+  const options = {
+    authUrl,
+    errorType: getStringExtension(error.extensions, 'errorType'),
+    retryable: typeof retryable === 'boolean' ? retryable : undefined,
+    statusCode: (_error$statusCode = error.statusCode) !== null && _error$statusCode !== void 0 ? _error$statusCode : status,
+    operationErrors
+  };
+  if (consentError && authUrl) {
+    return new IntegrationActionError('consent-required', error.message, options);
+  }
+  return new IntegrationActionError('operation', error.message, options);
+};
+const toGraphQLError = (graphQLErrors, statusCode) => {
+  const authUrl = graphQLErrors.map(error => getAuthUrl(error.extensions)).find(url => !!url);
+  const errorType = graphQLErrors.map(error => {
+    var _getStringExtension;
+    return (_getStringExtension = getStringExtension(error.extensions, 'errorType')) !== null && _getStringExtension !== void 0 ? _getStringExtension : getStringExtension(error.extensions, 'classification');
+  }).find(type => !!type);
+  const message = graphQLErrors.map(error => error.message).join('; ');
+  const options = {
+    authUrl,
+    errorType,
+    statusCode,
+    graphQLErrors
+  };
+  if (authUrl) {
+    return new IntegrationActionError('consent-required', message, options);
+  }
+  return new IntegrationActionError('graphql', message, options);
+};
+
+/**
+ * Turns an AGG response body into the action response, or throws an `IntegrationActionError`.
+ *
+ * Errors are checked in this order:
+ * 1. IS operation errors in `outputs.errors` (consent required, or the action failed).
+ * 2. GraphQL `errors`, even with a partial `execute` result. The mutation only selects
+ *    `actions.execute`, so any GraphQL error relates to the action.
+ * 3. A missing `execute` result.
+ * 4. A non-2xx `status` from IS.
+ */
+export const parseExecuteIntegrationActionResponse = (body, httpStatus) => {
+  var _body$data, _body$data$actions;
+  const execute = body === null || body === void 0 ? void 0 : (_body$data = body.data) === null || _body$data === void 0 ? void 0 : (_body$data$actions = _body$data.actions) === null || _body$data$actions === void 0 ? void 0 : _body$data$actions.execute;
+  const graphQLErrors = Array.isArray(body === null || body === void 0 ? void 0 : body.errors) && body.errors.length ? body.errors.map(toGraphQLErrorEntry) : undefined;
+  const operationErrors = getOperationErrors(execute === null || execute === void 0 ? void 0 : execute.outputs);
+  if (operationErrors !== null && operationErrors !== void 0 && operationErrors.length) {
+    throw toOperationError(operationErrors, execute === null || execute === void 0 ? void 0 : execute.status);
+  }
+  if (graphQLErrors) {
+    throw toGraphQLError(graphQLErrors, httpStatus);
+  }
+  if (!execute) {
+    throw new IntegrationActionError('graphql', 'No action result returned', {
+      statusCode: httpStatus
+    });
+  }
+  if (typeof execute.status === 'number' && !isSuccessStatus(execute.status)) {
+    throw new IntegrationActionError('operation', `Action failed with status ${execute.status}`, {
+      statusCode: execute.status
+    });
+  }
+  return {
+    status: execute.status,
+    outputs: execute.outputs
+  };
+};

package/dist/esm/services/use-integration-actions-client/build-request-headers.js

@@ -0,0 +1,35 @@
+import { ATTRIBUTION_SERVICE } from './constants';
+
+/**
+ * Smart Links product → GTM product name, from the AGG Metrics Attribution list.
+ * Products without a clear match are left out, so `product` is omitted from the header.
+ */
+var GTM_PRODUCT = {
+  ATLAS: 'Atlas',
+  BITBUCKET: 'Bitbucket Cloud',
+  CONFLUENCE: 'Confluence Cloud',
+  CSM: 'Customer Service Management',
+  JPD: 'Jira Product Discovery',
+  JSM: 'Jira Service Management',
+  JSW: 'Jira',
+  JWM: 'Jira',
+  TRELLO: 'Trello'
+};
+/**
+ * The `atl-attribution` header AGG asks frontend clients to send for metrics attribution:
+ * JSON with `tenantId`, `product` (when known) and `service`.
+ *
+ * See https://hello.atlassian.net/wiki/spaces/aggp/pages/5954141702
+ */
+export var buildRequestHeaders = function buildRequestHeaders(_ref) {
+  var cloudId = _ref.cloudId,
+    product = _ref.product;
+  var attribution = {
+    tenantId: cloudId || null,
+    product: product ? GTM_PRODUCT[product] : undefined,
+    service: ATTRIBUTION_SERVICE
+  };
+  return {
+    'atl-attribution': JSON.stringify(attribution)
+  };
+};

package/dist/esm/services/use-integration-actions-client/constants.js

@@ -0,0 +1,12 @@
+export var EXECUTE_INTEGRATION_ACTION_OPERATION_NAME = 'LinkClientExtension_ExecuteIntegrationAction';
+export var EXECUTE_INTEGRATION_ACTION_MUTATION = "mutation ".concat(EXECUTE_INTEGRATION_ACTION_OPERATION_NAME, "(\n\t$actionTypeKey: String\n\t$filter: ActionsExecuteActionFilter!\n\t$actionInput: ActionsExecuteActionInput!\n\t$workspace: String\n) {\n\tactions {\n\t\texecute(\n\t\t\tactionTypeKey: $actionTypeKey\n\t\t\tfilter: $filter\n\t\t\tactionInput: $actionInput\n\t\t\tworkspace: $workspace\n\t\t) {\n\t\t\tstatus\n\t\t\toutputs\n\t\t}\n\t}\n}");
+export var USER_CONSENT_REQUIRED = 'USER_CONSENT_REQUIRED';
+
+/** `service` value for the AGG `atl-attribution` header. */
+export var ATTRIBUTION_SERVICE = 'link-client-extension';
+
+/** Fallback message when IS reports an error without one. */
+export var GENERIC_OPERATION_ERROR_MESSAGE = 'Action failed';
+
+/** Fallback message when AGG returns a GraphQL error without one. */
+export var GENERIC_GRAPHQL_ERROR_MESSAGE = 'GraphQL error';

package/dist/esm/services/use-integration-actions-client/get-agg-url.js

@@ -0,0 +1,28 @@
+import { getBaseUrl } from '@atlaskit/linking-common/get-base-url';
+import { EXECUTE_INTEGRATION_ACTION_OPERATION_NAME } from './constants';
+var EDGE_PROXY_AGG_PATH = '/gateway/api/graphql';
+
+/**
+ * AGG endpoint for the CardClient's environment.
+ * - No envKey (running inside a product): same-origin `/gateway/api/graphql`. On the server there
+ *   is no `window`, so this is relative and requests fail with an `http` error instead of crashing.
+ * - `custom`: `baseUrlOverride` is a full object resolver URL (e.g. a direct service URL for SSR),
+ *   so we can't build an AGG URL from it. Use the relative edge proxy path instead, the same
+ *   fallback `getResolverUrl` uses.
+ * - Other envKeys (e.g. `stg` in examples): the Stargate base URL for that environment + `/graphql`,
+ *   e.g. `https://pug.jira-dev.com/gateway/api/graphql`.
+ * The operation name is added as a query param so requests are easy to identify.
+ */
+export var getAggUrl = function getAggUrl(envKey) {
+  var graphqlUrl;
+  if (envKey === 'custom') {
+    graphqlUrl = EDGE_PROXY_AGG_PATH;
+  } else if (envKey) {
+    var stargateBaseUrl = getBaseUrl(envKey);
+    graphqlUrl = "".concat(stargateBaseUrl.replace(/\/$/, ''), "/graphql");
+  } else {
+    var origin = getBaseUrl();
+    graphqlUrl = "".concat(origin).concat(EDGE_PROXY_AGG_PATH);
+  }
+  return "".concat(graphqlUrl, "?operationName=").concat(EXECUTE_INTEGRATION_ACTION_OPERATION_NAME);
+};

package/dist/esm/services/use-integration-actions-client/index.js

@@ -0,0 +1,136 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { useCallback, useMemo } from 'react';
+import { request } from '@atlaskit/linking-common/api';
+import { buildRequestHeaders } from './build-request-headers';
+import { EXECUTE_INTEGRATION_ACTION_MUTATION, EXECUTE_INTEGRATION_ACTION_OPERATION_NAME } from './constants';
+import { getAggUrl } from './get-agg-url';
+import { IntegrationActionError } from './integration-action-error';
+import { parseExecuteIntegrationActionResponse } from './parse-execute-integration-action-response';
+// Check the shape rather than `instanceof Response`; `instanceof` checks on errors have caused HOTs before.
+var isResponseLike = function isResponseLike(value) {
+  return _typeof(value) === 'object' && value !== null && typeof value.json === 'function';
+};
+var readErrorBody = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(response) {
+    var _t;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 1;
+          return response.json();
+        case 1:
+          return _context.abrupt("return", _context.sent);
+        case 2:
+          _context.prev = 2;
+          _t = _context["catch"](0);
+          return _context.abrupt("return", undefined);
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 2]]);
+  }));
+  return function readErrorBody(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var toHttpError = function toHttpError(error, statusCode) {
+  return new IntegrationActionError('http', error instanceof Error && error.message ? error.message : "Request failed".concat(statusCode ? " with status ".concat(statusCode) : ''), {
+    statusCode: statusCode,
+    originalError: error
+  });
+};
+/**
+ * useIntegrationActionsClient
+ *
+ * Runs Integrations Service (IS) actions on 3P resources (e.g. listing or adding Google Docs
+ * comments) through the AGG `actions { execute }` mutation. Uses a plain fetch rather than Relay,
+ * so it works in any host that provides a CardClient.
+ *
+ * `executeAction` resolves with the action's `outputs`. It throws an `IntegrationActionError` when:
+ * - the user needs to connect their 3P account (`kind: 'consent-required'`, with `authUrl`)
+ * - IS reports the action failed (`kind: 'operation'`)
+ * - AGG returns GraphQL errors (`kind: 'graphql'`)
+ * - the request fails (`kind: 'http'`)
+ *
+ * Each request sends the AGG metrics attribution header (`atl-attribution`), using
+ * `actionInput.cloudId` as the tenant.
+ *
+ * Call `executeAction` from effects or event handlers, not during render (it doesn't run in SSR).
+ *
+ * @param cardClient used to pick the AGG endpoint for the environment
+ * @param options.product product hosting the Smart Link, for metrics attribution
+ */
+export var useIntegrationActionsClient = function useIntegrationActionsClient(cardClient) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    product = _ref2.product;
+  var aggUrl = useMemo(function () {
+    return getAggUrl(cardClient === null || cardClient === void 0 ? void 0 : cardClient.envKey);
+  }, [cardClient === null || cardClient === void 0 ? void 0 : cardClient.envKey]);
+  var executeAction = useCallback( /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref3) {
+      var actionTypeKey, filter, actionInput, workspace, body, _errorBody$errors, _errorBody$data, errorBody, _t2;
+      return _regeneratorRuntime.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            actionTypeKey = _ref3.actionTypeKey, filter = _ref3.filter, actionInput = _ref3.actionInput, workspace = _ref3.workspace;
+            _context2.prev = 1;
+            _context2.next = 2;
+            return request('post', aggUrl, {
+              operationName: EXECUTE_INTEGRATION_ACTION_OPERATION_NAME,
+              query: EXECUTE_INTEGRATION_ACTION_MUTATION,
+              variables: {
+                actionTypeKey: actionTypeKey,
+                filter: filter,
+                actionInput: actionInput,
+                workspace: workspace
+              }
+            }, buildRequestHeaders({
+              cloudId: actionInput === null || actionInput === void 0 ? void 0 : actionInput.cloudId,
+              product: product
+            }), [200]);
+          case 2:
+            body = _context2.sent;
+            _context2.next = 7;
+            break;
+          case 3:
+            _context2.prev = 3;
+            _t2 = _context2["catch"](1);
+            if (!isResponseLike(_t2)) {
+              _context2.next = 6;
+              break;
+            }
+            _context2.next = 4;
+            return readErrorBody(_t2);
+          case 4:
+            errorBody = _context2.sent;
+            if (!(errorBody !== null && errorBody !== void 0 && (_errorBody$errors = errorBody.errors) !== null && _errorBody$errors !== void 0 && _errorBody$errors.length || errorBody !== null && errorBody !== void 0 && (_errorBody$data = errorBody.data) !== null && _errorBody$data !== void 0 && (_errorBody$data = _errorBody$data.actions) !== null && _errorBody$data !== void 0 && _errorBody$data.execute)) {
+              _context2.next = 5;
+              break;
+            }
+            return _context2.abrupt("return", parseExecuteIntegrationActionResponse(errorBody, _t2.status));
+          case 5:
+            throw toHttpError(undefined, _t2.status);
+          case 6:
+            throw toHttpError(_t2);
+          case 7:
+            return _context2.abrupt("return", parseExecuteIntegrationActionResponse(body, 200));
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, null, [[1, 3]]);
+    }));
+    return function (_x2) {
+      return _ref4.apply(this, arguments);
+    };
+  }(), [aggUrl, product]);
+  return useMemo(function () {
+    return {
+      executeAction: executeAction
+    };
+  }, [executeAction]);
+};

package/dist/esm/services/use-integration-actions-client/integration-action-error.js

@@ -0,0 +1,35 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+/** Thrown by `executeAction` when an action can't be run or fails. */
+export var IntegrationActionError = /*#__PURE__*/function (_Error) {
+  /** Set when `kind` is `consent-required`: where the user can connect their 3P account. */
+
+  /** HTTP status, or the status IS reported for the action. */
+
+  /** The underlying error, when the request itself failed. */
+
+  function IntegrationActionError(kind, message) {
+    var _this;
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, IntegrationActionError);
+    _this = _callSuper(this, IntegrationActionError, [message]);
+    _this.name = 'IntegrationActionError';
+    _this.kind = kind;
+    _this.authUrl = options.authUrl;
+    _this.errorType = options.errorType;
+    _this.retryable = options.retryable;
+    _this.statusCode = options.statusCode;
+    _this.graphQLErrors = options.graphQLErrors;
+    _this.operationErrors = options.operationErrors;
+    _this.originalError = options.originalError;
+    return _this;
+  }
+  _inherits(IntegrationActionError, _Error);
+  return _createClass(IntegrationActionError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));