@kineticdata/react 6.0.4 → 6.1.0

package/lib/components/integrator/connection/config_fields/http.js

@@ -0,0 +1,570 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeHttpConnectionConfigFields = exports.generateHttpConnectionConfigFields = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _immutable = require("immutable");
+var _integrationTypes = _interopRequireDefault(require("../../integrationTypes"));
+var serializeHttpConnectionConfigFields = exports.serializeHttpConnectionConfigFields = function serializeHttpConnectionConfigFields(configFields) {
+  return function (_ref) {
+    var values = _ref.values;
+    return configFields.reduce(function (serialization, _ref2) {
+      var name = _ref2.name,
+        type = _ref2.type,
+        visible = _ref2.visible,
+        _transient = _ref2["transient"];
+      if (
+      // Field must not be transient
+      !_transient && (
+      // Field must be visible
+      typeof visible === 'function' ? visible({
+        values: values
+      }) : typeof visible === 'undefined' || !!visible)) {
+        // Set password fields to null if their toggle field is
+        // false, which means the password wasn't changed
+        if (type === 'password' && !values.get("".concat(name, ".toggle"))) {
+          return serialization.setIn(name.split('.'), null);
+        }
+
+        // If auth type is not selected, set the auth property to null
+        if (name === 'auth.authType' && !values.get(name)) {
+          return serialization.setIn(['auth'], null);
+        }
+
+        // Set the following fields to null if they don't have a value
+        if (['caCert', 'auth.caCert', 'auth.scope', 'auth.token.connection.caCert', 'auth.transform'].includes(name) && !values.get(name)) {
+          return serialization.setIn(name.split('.'), null);
+        }
+
+        // Set the value into the correct structure
+        return serialization.setIn(name.split('.'), values.get(name));
+      }
+      return serialization;
+    }, (0, _immutable.Map)());
+  };
+};
+var generateHttpConnectionConfigFields = exports.generateHttpConnectionConfigFields = function generateHttpConnectionConfigFields(config) {
+  return [{
+    name: 'configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: 'http',
+    required: true,
+    enabled: false
+  }, {
+    name: 'baseUrl',
+    label: 'Base URL',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'baseUrl'),
+    required: true,
+    placeholder: 'https://www.kineticdata.com'
+  }, {
+    name: 'testPath',
+    label: 'Test Path',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'testPath'),
+    helpText: 'Path to a GET endpoint to be used for testing the connection and checking the health status.'
+  }, {
+    name: 'caCert',
+    label: 'Trusted CA Certificate',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'caCert') || ''
+  }].concat((0, _toConsumableArray2["default"])(generateHttpConnectionConfigAuthFields((0, _immutable.get)(config, 'auth'), !config)));
+};
+var generateHttpConnectionConfigAuthFields = function generateHttpConnectionConfigAuthFields(auth) {
+  return [{
+    name: 'auth.authType',
+    label: 'Authentication',
+    type: 'select',
+    options: [{
+      value: 'basic',
+      label: 'Basic Auth'
+    }, {
+      value: 'http_bearer_token',
+      label: 'HTTP Bearer Token'
+    }, {
+      value: 'raw_bearer_token',
+      label: 'Raw Bearer Token'
+    }, {
+      value: 'client_credentials',
+      label: 'OAuth 2.0'
+    }],
+    initialValue: (0, _immutable.get)(auth, 'authType'),
+    placeholder: 'None'
+  },
+  // basic
+  {
+    name: 'auth.username',
+    label: 'Username',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'username'),
+    required: function required(_ref3) {
+      var values = _ref3.values;
+      return values.get('auth.authType') === 'basic';
+    },
+    visible: function visible(_ref4) {
+      var values = _ref4.values;
+      return values.get('auth.authType') === 'basic';
+    }
+  }, {
+    name: 'auth.password.toggle',
+    "transient": true,
+    label: 'Modify Password',
+    type: 'toggle',
+    // Set to true if there is no auth config or if the current auth config is
+    // set to a different type
+    initialValue: !auth || (0, _immutable.get)(auth, 'authType') !== 'basic',
+    // Show if we're editing a connection and the selected auth type matches
+    // the currently saved auth type
+    visible: function visible(_ref5) {
+      var values = _ref5.values,
+        connection = _ref5.connection;
+      return !!connection && values.get('auth.authType') === 'basic' && connection.getIn(['config', 'auth', 'authType']) === 'basic';
+    }
+  }, {
+    name: 'auth.password',
+    label: 'Password',
+    type: 'password',
+    initialValue: '',
+    visible: function visible(_ref6) {
+      var values = _ref6.values;
+      return values.get('auth.authType') === 'basic';
+    },
+    // Enable if we're creating a new connection or the change toggle is true
+    enabled: function enabled(_ref7) {
+      var values = _ref7.values,
+        connection = _ref7.connection;
+      return !connection || !!values.get('auth.password.toggle');
+    },
+    // Show the placeholder if there is a connection and it matches the saved type
+    placeholder: function placeholder(_ref8) {
+      var values = _ref8.values,
+        connection = _ref8.connection;
+      return !!connection && connection.getIn(['config', 'auth', 'authType']) === 'basic' && !values.get('auth.password.toggle') ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : undefined;
+    }
+  },
+  // client_credentials
+  {
+    name: 'auth.tokenUrl',
+    label: 'Access Token URL',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'tokenUrl'),
+    required: function required(_ref9) {
+      var values = _ref9.values;
+      return values.get('auth.authType') === 'client_credentials';
+    },
+    visible: function visible(_ref10) {
+      var values = _ref10.values;
+      return values.get('auth.authType') === 'client_credentials';
+    }
+  }, {
+    name: 'auth.clientId',
+    label: 'Client ID',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'clientId'),
+    required: function required(_ref11) {
+      var values = _ref11.values;
+      return values.get('auth.authType') === 'client_credentials';
+    },
+    visible: function visible(_ref12) {
+      var values = _ref12.values;
+      return values.get('auth.authType') === 'client_credentials';
+    }
+  }, {
+    name: 'auth.clientSecret.toggle',
+    "transient": true,
+    label: 'Modify Client Secret',
+    type: 'toggle',
+    // Set to true if there is no auth config or if the current auth config is
+    // set to a different type
+    initialValue: !auth || (0, _immutable.get)(auth, 'authType') !== 'client_credentials',
+    // Show if we're editing a connection and the selected auth type matches
+    // the currently saved auth type
+    visible: function visible(_ref13) {
+      var values = _ref13.values,
+        connection = _ref13.connection;
+      return !!connection && values.get('auth.authType') === 'client_credentials' && connection.getIn(['config', 'auth', 'authType']) === 'client_credentials';
+    }
+  }, {
+    name: 'auth.clientSecret',
+    label: 'Client Secret',
+    type: 'password',
+    visible: function visible(_ref14) {
+      var values = _ref14.values;
+      return values.get('auth.authType') === 'client_credentials';
+    },
+    // Enable if we're creating a new connection or the change toggle is true
+    enabled: function enabled(_ref15) {
+      var values = _ref15.values,
+        connection = _ref15.connection;
+      return !connection || !!values.get('auth.clientSecret.toggle');
+    },
+    // Show the placeholder if there is a connection and it matches the saved type
+    placeholder: function placeholder(_ref16) {
+      var values = _ref16.values,
+        connection = _ref16.connection;
+      return !!connection && connection.getIn(['config', 'auth', 'authType']) === 'client_credentials' && !values.get('auth.clientSecret.toggle') ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : undefined;
+    }
+  }, {
+    name: 'auth.scope',
+    label: 'Scope',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'scope'),
+    visible: function visible(_ref17) {
+      var values = _ref17.values;
+      return values.get('auth.authType') === 'client_credentials';
+    }
+  }, {
+    name: 'auth.clientAuth',
+    label: 'Client Auth',
+    type: 'select',
+    options: [{
+      label: 'Basic Auth',
+      value: 'basic_auth'
+    }, {
+      label: 'Form URL Encoded',
+      value: 'www_form_urlencoded'
+    }],
+    initialValue: (0, _immutable.get)(auth, 'clientAuth', 'www_form_urlencoded'),
+    required: function required(_ref18) {
+      var values = _ref18.values;
+      return values.get('auth.authType') === 'client_credentials';
+    },
+    visible: function visible(_ref19) {
+      var values = _ref19.values;
+      return values.get('auth.authType') === 'client_credentials';
+    }
+  }, {
+    name: 'auth.caCert',
+    label: 'Trusted CA Certificate',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'caCert') || '',
+    visible: function visible(_ref20) {
+      var values = _ref20.values;
+      return values.get('auth.authType') === 'client_credentials';
+    }
+  },
+  // bearer_token
+  {
+    name: 'auth.header',
+    label: 'Token Header',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'header', 'Authorization'),
+    visible: function visible(_ref21) {
+      var values = _ref21.values;
+      return ['raw_bearer_token', 'http_bearer_token'].includes(values.get('auth.authType'));
+    },
+    required: function required(_ref22) {
+      var values = _ref22.values;
+      return ['raw_bearer_token', 'http_bearer_token'].includes(values.get('auth.authType'));
+    }
+  }, {
+    name: 'auth.prefix',
+    label: 'Token Prefix',
+    type: 'text',
+    initialValue: (0, _immutable.get)(auth, 'prefix', 'Bearer'),
+    visible: function visible(_ref23) {
+      var values = _ref23.values;
+      return ['raw_bearer_token', 'http_bearer_token'].includes(values.get('auth.authType'));
+    },
+    required: function required(_ref24) {
+      var values = _ref24.values;
+      return ['raw_bearer_token', 'http_bearer_token'].includes(values.get('auth.authType'));
+    }
+  }, {
+    name: 'auth.token.toggle',
+    "transient": true,
+    label: 'Modify Token',
+    type: 'toggle',
+    // Set to true if there is no auth config or if the current auth config is
+    // set to a different type
+    initialValue: !auth || (0, _immutable.get)(auth, 'authType') !== 'raw_bearer_token',
+    // Show if we're editing a connection and the selected auth type matches
+    // the currently saved auth type
+    visible: function visible(_ref25) {
+      var values = _ref25.values,
+        connection = _ref25.connection;
+      return !!connection && values.get('auth.authType') === 'raw_bearer_token' && connection.getIn(['config', 'auth', 'authType']) === 'raw_bearer_token';
+    }
+  }, {
+    name: 'auth.token',
+    label: 'Token',
+    type: 'password',
+    initialValue: '',
+    visible: function visible(_ref26) {
+      var values = _ref26.values;
+      return values.get('auth.authType') === 'raw_bearer_token';
+    },
+    // Enable if we're creating a new connection or the change toggle is true
+    enabled: function enabled(_ref27) {
+      var values = _ref27.values,
+        connection = _ref27.connection;
+      return !connection || !!values.get('auth.token.toggle');
+    },
+    // Show the placeholder if there is a connection and it matches the saved type
+    placeholder: function placeholder(_ref28) {
+      var values = _ref28.values,
+        connection = _ref28.connection;
+      return !!connection && connection.getIn(['config', 'auth', 'authType']) === 'raw_bearer_token' && !values.get('auth.token.toggle') ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : undefined;
+    }
+  }].concat((0, _toConsumableArray2["default"])(generateHttpConnectionConfigAuthTokenOperationFields((0, _immutable.getIn)(auth, ['token', 'operation']))), [{
+    name: 'auth.tokenHttpConn',
+    "transient": true,
+    label: 'Use different connection for auth',
+    type: 'checkbox',
+    initialValue: typeof (0, _immutable.getIn)(auth, ['token', 'connection']) === 'object',
+    visible: function visible(_ref29) {
+      var values = _ref29.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }], (0, _toConsumableArray2["default"])(generateHttpConnectionConfigAuthTokenConnectionFields((0, _immutable.getIn)(auth, ['token', 'connection']))), [{
+    name: 'auth.token.tokenOutput',
+    label: 'Token',
+    type: 'code',
+    language: 'js-expression',
+    initialValue: (0, _immutable.getIn)(auth, ['token', 'tokenOutput']),
+    required: function required(_ref30) {
+      var values = _ref30.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    visible: function visible(_ref31) {
+      var values = _ref31.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Define a JavaScript expression that maps the response to the token value. Press ", /*#__PURE__*/React.createElement("code", null, "Ctrl + Space"), " to see the available properties in the field.")
+  }, {
+    name: 'auth.token.expirationOutput',
+    label: 'Expiration',
+    type: 'code',
+    language: 'js-expression',
+    initialValue: (0, _immutable.getIn)(auth, ['token', 'expirationOutput']),
+    required: function required(_ref32) {
+      var values = _ref32.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    visible: function visible(_ref33) {
+      var values = _ref33.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Define a JavaScript expression that maps the response to a numeric expiration value in seconds. Press ", /*#__PURE__*/React.createElement("code", null, "Ctrl + Space"), " to see the available properties in the field.")
+  }]);
+};
+var generateHttpConnectionConfigAuthTokenOperationFields = function generateHttpConnectionConfigAuthTokenOperationFields(operation) {
+  return [{
+    name: 'auth.token.operation.configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: 'http',
+    enabled: false,
+    visible: function visible(_ref34) {
+      var values = _ref34.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    required: function required(_ref35) {
+      var values = _ref35.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }, {
+    name: 'auth.token.operation.method',
+    label: 'Method',
+    type: 'select',
+    options: [{
+      label: 'GET',
+      value: 'GET'
+    }, {
+      label: 'POST',
+      value: 'POST'
+    }, {
+      label: 'PUT',
+      value: 'PUT'
+    }, {
+      label: 'PATCH',
+      value: 'PATCH'
+    }, {
+      label: 'DELETE',
+      value: 'DELETE'
+    }],
+    initialValue: (0, _immutable.get)(operation, 'method'),
+    visible: function visible(_ref36) {
+      var values = _ref36.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    required: function required(_ref37) {
+      var values = _ref37.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }, {
+    name: 'auth.token.operation.path',
+    label: 'Request Path',
+    type: 'text',
+    initialValue: (0, _immutable.get)(operation, 'path'),
+    visible: function visible(_ref38) {
+      var values = _ref38.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    required: function required(_ref39) {
+      var values = _ref39.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }, {
+    name: 'auth.token.operation.params',
+    label: 'URL Parameters',
+    type: 'map',
+    initialValue: (0, _immutable.get)(operation, 'params'),
+    visible: function visible(_ref40) {
+      var values = _ref40.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    placeholder: 'Parameter Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }, {
+    name: 'auth.token.operation.headers',
+    label: 'Headers',
+    type: 'map',
+    initialValue: (0, _immutable.get)(operation, 'headers'),
+    visible: function visible(_ref41) {
+      var values = _ref41.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    },
+    placeholder: 'Header Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }, {
+    name: 'auth.token.operation.followRedirect',
+    label: 'Follow Redirect',
+    type: 'checkbox',
+    initialValue: (0, _immutable.get)(operation, 'followRedirect'),
+    visible: function visible(_ref42) {
+      var values = _ref42.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }, {
+    name: 'auth.token.operation.streamResponse',
+    label: 'Stream Response',
+    type: 'checkbox',
+    initialValue: (0, _immutable.get)(operation, 'streamResponse'),
+    visible: function visible(_ref43) {
+      var values = _ref43.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }, {
+    name: 'auth.token.operation.body.bodyType',
+    label: 'Body Type',
+    type: 'radio',
+    options: [{
+      label: 'Form URL Encoded',
+      value: 'www_form_urlencoded'
+    }, {
+      label: 'Raw',
+      value: 'raw'
+    }
+    // { label: 'Multipart', value: 'multipart_form' },
+    ],
+
+    initialValue: (0, _immutable.getIn)(operation, ['body', 'bodyType']) || 'www_form_urlencoded',
+    required: true,
+    visible: function visible(_ref44) {
+      var values = _ref44.values;
+      return values.get('auth.authType') === 'http_bearer_token';
+    }
+  }, {
+    name: 'auth.token.operation.body.form',
+    label: 'Form Body',
+    type: 'map',
+    initialValue: (0, _immutable.getIn)(operation, ['body', 'form']),
+    visible: function visible(_ref45) {
+      var values = _ref45.values;
+      return values.get('auth.authType') === 'http_bearer_token' && values.get('auth.token.operation.body.bodyType') === 'www_form_urlencoded';
+    },
+    placeholder: 'Body Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }, {
+    name: 'auth.token.operation.body.raw',
+    label: 'Raw Body',
+    type: 'code',
+    language: function language(_ref46) {
+      var values = _ref46.values;
+      return getLanguageFromContentType(values.get('auth.token.operation.headers').find(function (_, header) {
+        return (header === null || header === void 0 ? void 0 : header.toLowerCase()) === 'content-type';
+      }));
+    },
+    initialValue: (0, _immutable.getIn)(operation, ['body', 'raw']),
+    visible: function visible(_ref47) {
+      var values = _ref47.values;
+      return values.get('auth.authType') === 'http_bearer_token' && values.get('auth.token.operation.body.bodyType') === 'raw';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }, {
+    name: 'auth.token.operation.body.parts',
+    label: 'Multipart Body',
+    type: 'table',
+    options: [{
+      name: 'name',
+      label: 'Name',
+      type: 'text'
+    }, {
+      name: 'contentType',
+      label: 'Content Type',
+      type: 'text'
+    }, {
+      name: 'content',
+      label: 'Content',
+      type: 'code',
+      renderAttributes: {
+        simple: true,
+        max: 'sm'
+      }
+    }, {
+      name: 'fileName',
+      label: 'File Name',
+      type: 'text'
+    }],
+    initialValue: (0, _immutable.getIn)(operation, ['body', 'parts'], (0, _immutable.List)()),
+    visible: function visible(_ref48) {
+      var values = _ref48.values;
+      return values.get('auth.authType') === 'http_bearer_token' && values.get('auth.token.operation.body.bodyType') === 'multipart_form';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{secretKey}}'), " format to insert secrets that have been defined for this connection.")
+  }];
+};
+var generateHttpConnectionConfigAuthTokenConnectionFields = function generateHttpConnectionConfigAuthTokenConnectionFields(connection) {
+  return [{
+    name: 'auth.token.connection.baseUrl',
+    label: 'Token Base URL',
+    type: 'text',
+    initialValue: (0, _immutable.get)(connection, 'baseUrl'),
+    visible: function visible(_ref49) {
+      var values = _ref49.values;
+      return values.get('auth.authType') === 'http_bearer_token' && !!values.get('auth.tokenHttpConn');
+    },
+    required: function required(_ref50) {
+      var values = _ref50.values;
+      return values.get('auth.authType') === 'http_bearer_token' && !!values.get('auth.tokenHttpConn');
+    }
+  }, {
+    name: 'auth.token.connection.caCert',
+    label: 'Token Trusted CA Certificate',
+    type: 'text',
+    initialValue: (0, _immutable.get)(connection, 'caCert') || '',
+    visible: function visible(_ref51) {
+      var values = _ref51.values;
+      return values.get('auth.authType') === 'http_bearer_token' && !!values.get('auth.tokenHttpConn');
+    }
+  }];
+};
+function getLanguageFromContentType(contentType) {
+  switch (contentType) {
+    case 'application/json':
+      return 'json';
+    case 'application/xml':
+    case 'text/xml':
+      return 'xml';
+    default:
+      return 'none';
+  }
+}

package/lib/components/integrator/integrationTypes.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.integrationTypes = exports.getOperationMetadata = exports.getConnectionMetadata = exports["default"] = void 0;
+var _immutable = require("immutable");
+var integrationTypes = exports.integrationTypes = [{
+  label: 'HTTP',
+  value: 'http'
+}
+// { label: 'SMTP', value: 'smtp' },
+// { label: 'SQL', value: 'sql' },
+];
+
+// Helper function for getting the label for a given type value
+integrationTypes.getLabel = function (value) {
+  var _integrationTypes$fin;
+  return ((_integrationTypes$fin = integrationTypes.find(function (t) {
+    return t.value === value;
+  })) === null || _integrationTypes$fin === void 0 ? void 0 : _integrationTypes$fin.label) || value;
+};
+var _default = exports["default"] = integrationTypes;
+var getConnectionMetadata = exports.getConnectionMetadata = function getConnectionMetadata(connection) {
+  var type = (0, _immutable.getIn)(connection, ['config', 'configType']);
+  switch (type) {
+    case 'http':
+      return {
+        // Details content to render for each option in a list of connections
+        optionDetail: (0, _immutable.getIn)(connection, ['config', 'baseUrl']),
+        // Documentation link
+        docsLink: (0, _immutable.getIn)(connection, ['documentationLink']),
+        // Properties to list in page/modal headings
+        headingData: [{
+          label: 'Base URL',
+          value: (0, _immutable.getIn)(connection, ['config', 'baseUrl'])
+        }, {
+          label: 'Auth',
+          value: {
+            basic: 'Basic',
+            client_credentials: 'Client Credentials',
+            http_bearer_token: 'HTTP Bearer Token',
+            raw_bearer_token: 'Raw Bearer Token'
+          }[(0, _immutable.getIn)(connection, ['config', 'auth', 'authType'])] || 'None'
+        }].filter(function (o) {
+          return o.value;
+        }),
+        // Table columns for the operations table of this type of connection.
+        // Objects define columns to add, and strings define default columns to
+        // show. The order of the items is defines the order of the columns.
+        operationColumns: [{
+          value: 'method',
+          title: 'Method',
+          components: {
+            BodyCell: HTTPMethodCell
+          },
+          toggleable: true
+        }, 'name', 'updatedAt', 'actions']
+      };
+    default:
+      return {
+        headingData: [],
+        operationColumns: ['name', 'updatedAt', 'actions']
+      };
+  }
+};
+var getOperationMetadata = exports.getOperationMetadata = function getOperationMetadata(operation) {
+  var type = (0, _immutable.getIn)(operation, ['config', 'configType']);
+  switch (type) {
+    case 'http':
+      return {
+        // Details content to render for each option in a list of operations
+        optionDetail: (0, _immutable.getIn)(operation, ['config', 'method']),
+        // Documentation link
+        docsLink: (0, _immutable.getIn)(operation, ['documentationLink']),
+        // Properties to list in page/modal headings
+        headingData: [{
+          label: 'Request Path',
+          value: (0, _immutable.getIn)(operation, ['config', 'path'])
+        }, {
+          label: 'Method',
+          value: (0, _immutable.getIn)(operation, ['config', 'method'])
+        }].filter(function (o) {
+          return o.value;
+        })
+      };
+    default:
+      return {
+        headingData: []
+      };
+  }
+};
+var HTTPMethodCell = function HTTPMethodCell(_ref) {
+  var row = _ref.row;
+  return /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("span", {
+    className: "badge badge-info"
+  }, row.getIn(['config', 'method'])));
+};