@kineticdata/react 6.0.5 → 6.1.1

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, options) {
+  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'), options)));
+};
+var generateHttpConnectionConfigAuthFields = function generateHttpConnectionConfigAuthFields(auth, options) {
+  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 || options.isClone || options.isNewImport || (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 && !options.isClone && 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 || options.isClone || !!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 && !options.isClone && 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 || options.isClone || options.isNewImport || (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 && !options.isClone && 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 || options.isClone || !!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 && !options.isClone && 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 || options.isClone || options.isNewImport || (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 && !options.isClone && 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 || options.isClone || !!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 && !options.isClone && 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']), options)), [{
+    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']), options)), [{
+    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, options) {
+  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, options) {
+  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/connection/config_fields/sql.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeSQLConnectionConfigFields = exports.generateSQLConnectionConfigFields = void 0;
+var _immutable = require("immutable");
+var _integrationTypes = _interopRequireDefault(require("../../integrationTypes"));
+var serializeSQLConnectionConfigFields = exports.serializeSQLConnectionConfigFields = function serializeSQLConnectionConfigFields(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);
+        }
+
+        // Set the following fields to null if they don't have a value
+        if (['caCert'].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 generateSQLConnectionConfigFields = exports.generateSQLConnectionConfigFields = function generateSQLConnectionConfigFields(config, type, options) {
+  return [{
+    name: 'configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: type,
+    required: true,
+    enabled: false
+  }, {
+    name: 'host',
+    label: 'Host',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'host'),
+    required: true
+  }, {
+    name: 'port',
+    label: 'Port',
+    type: 'text',
+    initialValue: String((0, _immutable.get)(config, 'port') || ''),
+    required: true,
+    pattern: /^\d*$/,
+    patternMessage: 'Port must be numeric'
+  }, {
+    name: 'database',
+    label: 'Database',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'database'),
+    required: true
+  }, {
+    name: 'poolSize',
+    label: 'Connection Pool',
+    type: 'number',
+    initialValue: (0, _immutable.get)(config, 'poolSize') || 5,
+    required: true,
+    constraint: function constraint(_ref3) {
+      var values = _ref3.values;
+      return typeof values.get('poolSize') === 'number' && values.get('poolSize') > 0;
+    },
+    constraintMessage: 'Connection Pool must be numeric and must be greater than 0'
+  }, {
+    name: 'username',
+    label: 'Username',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'username'),
+    required: true
+  }, {
+    name: 'password.toggle',
+    "transient": true,
+    label: 'Modify Password',
+    type: 'toggle',
+    initialValue: !config || !!options.isClone || !!options.isNewImport,
+    // Show if we're editing a connection
+    visible: function visible(_ref4) {
+      var connection = _ref4.connection;
+      return !!connection && !options.isClone;
+    }
+  }, {
+    name: 'password',
+    label: 'Password',
+    type: 'password',
+    initialValue: '',
+    // Enable if we're creating a new connection or the change toggle is true
+    enabled: function enabled(_ref5) {
+      var values = _ref5.values,
+        connection = _ref5.connection;
+      return !connection || options.isClone || !!values.get('password.toggle');
+    },
+    // Show the placeholder if there is a connection
+    placeholder: function placeholder(_ref6) {
+      var values = _ref6.values,
+        connection = _ref6.connection;
+      return !!connection && !options.isClone && !values.get('password.toggle') ? "\u2022\u2022\u2022\u2022\u2022\u2022\u2022" : undefined;
+    }
+  }, {
+    name: 'caCert',
+    label: 'Trusted CA Certificate',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'caCert') || ''
+  }];
+};