@kineticdata/react 6.0.5 → 6.1.1

package/lib/components/integrator/integrationTypes.js

@@ -0,0 +1,120 @@
+"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: 'PostgreSQL',
+  value: 'postgres',
+  group: 'sql',
+  groupLabel: 'SQL'
+}, {
+  label: 'SQL Server',
+  value: 'mssql',
+  group: 'sql',
+  groupLabel: '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']),
+        optionDetailLabel: 'Base URL',
+        // 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: 'OAuth 2.0',
+            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 defines the order of the columns.
+        operationColumns: [{
+          value: 'method',
+          title: 'Method',
+          components: {
+            BodyCell: HTTPMethodCell
+          },
+          toggleable: true
+        }, 'name', 'updatedAt', 'actions']
+      };
+    case 'postgres':
+    case 'mssql':
+    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']),
+        optionDetailLabel: 'Method',
+        optionDetailComponent: HTTPMethod,
+        // 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;
+        })
+      };
+    case 'postgres':
+    case 'mssql':
+    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'])));
+};
+var HTTPMethod = function HTTPMethod(_ref2) {
+  var value = _ref2.value;
+  return /*#__PURE__*/React.createElement("span", {
+    className: "badge badge-info"
+  }, value);
+};

package/lib/components/integrator/operation/OperationForm.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OperationForm = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/slicedToArray"));
+var _immutable = require("immutable");
+var _Form = require("../../form/Form");
+var _apis = require("../../../apis");
+var _http = require("./config_fields/http");
+var _sql = require("./config_fields/sql");
+var dataSources = function dataSources(_ref) {
+  var id = _ref.id,
+    connectionId = _ref.connectionId;
+  return {
+    connection: {
+      fn: _apis.fetchConnection,
+      params: connectionId && [{
+        id: connectionId
+      }],
+      transform: function transform(result) {
+        return result.connection;
+      }
+    },
+    operation: {
+      fn: _apis.fetchOperation,
+      params: id && connectionId && [{
+        id: id,
+        connectionId: connectionId
+      }],
+      transform: function transform(result) {
+        return result.operation;
+      }
+    }
+  };
+};
+var handleSubmit = function handleSubmit(_ref2) {
+  var id = _ref2.id,
+    connectionId = _ref2.connectionId,
+    clone = _ref2.clone;
+  return function (values) {
+    return (id && !clone ? _apis.updateOperation : _apis.createOperation)({
+      id: id,
+      connectionId: connectionId,
+      operation: values.toJS()
+    }).then(function (_ref3) {
+      var operation = _ref3.operation,
+        error = _ref3.error;
+      if (error) {
+        throw error.statusCode === 400 && error.message || 'There was an error saving the operation';
+      }
+      return operation;
+    });
+  };
+};
+var getFieldConfigByType = function getFieldConfigByType(type, operation) {
+  switch (type) {
+    case 'http':
+      var configFieldsHTTP = (0, _http.generateHttpOperationConfigFields)((0, _immutable.get)(operation, 'config'));
+      return [configFieldsHTTP, (0, _http.serializeHttpOperationConfigFields)(configFieldsHTTP)];
+    case 'postgres':
+      var configFieldsPostgres = (0, _sql.generatePostgresOperationConfigFields)((0, _immutable.get)(operation, 'config'));
+      return [configFieldsPostgres, (0, _sql.serializeSQLOperationConfigFields)(configFieldsPostgres)];
+    case 'mssql':
+      var configFieldsMSSQL = (0, _sql.generateMSSQLOperationConfigFields)((0, _immutable.get)(operation, 'config'));
+      return [configFieldsMSSQL, (0, _sql.serializeSQLOperationConfigFields)(configFieldsMSSQL)];
+    default:
+      return [[], undefined];
+  }
+};
+var fields = function fields(_ref4) {
+  var id = _ref4.id,
+    clone = _ref4.clone;
+  return function (_ref5) {
+    var operation = _ref5.operation,
+      connection = _ref5.connection;
+    if (connection && (!id || operation)) {
+      // Set type from the operation if it exists, or from the connection
+      var typeValue = (0, _immutable.getIn)(connection, ['config', 'configType']);
+      var _getFieldConfigByType = getFieldConfigByType(typeValue, operation),
+        _getFieldConfigByType2 = (0, _slicedToArray2["default"])(_getFieldConfigByType, 2),
+        configFields = _getFieldConfigByType2[0],
+        configSerialize = _getFieldConfigByType2[1];
+      return [{
+        name: 'name',
+        label: 'Operation Name',
+        type: 'text',
+        initialValue: !clone ? (0, _immutable.get)(operation, 'name') : '',
+        required: true,
+        placeholder: !clone ? 'Enter a name to find your operation easily' : "Clone of ".concat((0, _immutable.get)(operation, 'name'))
+      }, {
+        name: 'documentationLink',
+        label: 'API Documentation Link',
+        type: 'text',
+        initialValue: (0, _immutable.get)(operation, 'documentationLink') || '',
+        placeholder: 'Optional (but recommended)'
+      }, {
+        name: 'notes',
+        label: 'Description',
+        type: 'text',
+        initialValue: (0, _immutable.get)(operation, 'notes') || '',
+        placeholder: 'Enter a short description for the operation'
+      }, {
+        name: 'outputs',
+        label: 'Outputs',
+        type: 'map',
+        initialValue: (0, _immutable.get)(operation, 'outputs') || {},
+        placeholder: 'Output Key',
+        serialize: function serialize(_ref6) {
+          var values = _ref6.values;
+          return values.get('outputs');
+        },
+        constraint: function constraint(_ref7) {
+          var values = _ref7.values;
+          return values.get('outputs').every(function (value, key) {
+            return key && key.match(/^[a-z\d_-]+[a-z\d\s_-]*$/i) && (!value.get('children') || value.get('children').every(function (_, childKey) {
+              return childKey && childKey.match(/^[a-z\d_-]+[a-z\d\s_-]*$/i);
+            }));
+          });
+        },
+        constraintMessage: ''
+      }, {
+        name: 'config',
+        label: 'Config',
+        type: null,
+        visible: false,
+        initialValue: (0, _immutable.get)(operation, 'config'),
+        // Serialize the transient config fields into a single config object
+        serialize: configSerialize
+      }].concat((0, _toConsumableArray2["default"])(configFields.map(function (field) {
+        return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, field), {}, {
+          "transient": true
+        });
+      })));
+    }
+  };
+};
+var OperationForm = exports.OperationForm = (0, _Form.generateForm)({
+  formOptions: ['id', 'connectionId', 'clone'],
+  dataSources: dataSources,
+  fields: fields,
+  handleSubmit: handleSubmit
+});
+OperationForm.displayName = 'OperationForm';

package/lib/components/integrator/operation/OperationTable.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OperationTable = void 0;
+var _apis = require("../../../apis");
+var _Table = require("../../table/Table");
+var _helpers = require("../../../helpers");
+var filters = function filters() {
+  return function () {
+    return [{
+      name: 'name',
+      label: 'Name',
+      type: 'text'
+    }];
+  };
+};
+var clientSide = (0, _helpers.defineFilter)(true).matches('name', 'name').end();
+var dataSource = function dataSource(_ref) {
+  var connectionId = _ref.connectionId;
+  return {
+    fn: _apis.fetchOperations,
+    clientSide: clientSide,
+    params: function params() {
+      return connectionId && [{
+        connectionId: connectionId
+      }];
+    },
+    transform: function transform(result) {
+      return {
+        data: result.operations
+      };
+    }
+  };
+};
+var columns = [{
+  value: 'name',
+  title: 'Name',
+  sortable: true
+}, {
+  value: 'id',
+  title: 'Id',
+  toggleable: true
+}, {
+  value: 'insertedAt',
+  title: 'Created At',
+  sortable: true,
+  toggleable: true
+}, {
+  value: 'updatedAt',
+  title: 'Updated At',
+  sortable: true,
+  toggleable: true
+}];
+var OperationTable = exports.OperationTable = (0, _Table.generateTable)({
+  tableOptions: ['connectionId'],
+  columns: columns,
+  filters: filters,
+  dataSource: dataSource
+});
+OperationTable.displayName = 'OperationTable';

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

@@ -0,0 +1,185 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeHttpOperationConfigFields = exports.generateHttpOperationConfigFields = void 0;
+var _immutable = require("immutable");
+var _integrationTypes = _interopRequireDefault(require("../../integrationTypes"));
+var serializeHttpOperationConfigFields = exports.serializeHttpOperationConfigFields = function serializeHttpOperationConfigFields(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 the value into the correct structure
+        return serialization.setIn(name.split('.'), values.get(name));
+      }
+      return serialization;
+    }, (0, _immutable.Map)());
+  };
+};
+var generateHttpOperationConfigFields = exports.generateHttpOperationConfigFields = function generateHttpOperationConfigFields(config) {
+  return [{
+    name: 'configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: 'http',
+    required: true,
+    enabled: false
+  }, {
+    name: '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)(config, 'method'),
+    required: true
+  }, {
+    name: 'path',
+    label: 'Request Path',
+    type: 'text',
+    initialValue: (0, _immutable.get)(config, 'path'),
+    required: true,
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }, {
+    name: 'params',
+    label: 'URL Parameters',
+    type: 'map',
+    initialValue: (0, _immutable.get)(config, 'params'),
+    placeholder: 'Parameter Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }, {
+    name: 'headers',
+    label: 'Headers',
+    type: 'map',
+    initialValue: (0, _immutable.get)(config, 'headers'),
+    placeholder: 'Header Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }, {
+    name: 'followRedirect',
+    label: 'Follow Redirect',
+    type: 'checkbox',
+    initialValue: (0, _immutable.get)(config, 'followRedirect')
+  }, {
+    name: 'streamResponse',
+    label: 'Stream Response',
+    type: 'checkbox',
+    initialValue: (0, _immutable.get)(config, 'streamResponse')
+  }, {
+    name: 'includeEmptyParams',
+    label: 'Include Empty Parameters',
+    type: 'checkbox',
+    initialValue: (0, _immutable.get)(config, 'includeEmptyParams')
+  }, {
+    name: '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)(config, ['body', 'bodyType']) || 'www_form_urlencoded'
+  }, {
+    name: 'body.form',
+    label: 'Form Body',
+    type: 'map',
+    initialValue: (0, _immutable.getIn)(config, ['body', 'form']),
+    visible: function visible(_ref3) {
+      var values = _ref3.values;
+      return values.get('body.bodyType') === 'www_form_urlencoded';
+    },
+    placeholder: 'Body Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }, {
+    name: 'body.raw',
+    label: 'Raw Body',
+    type: 'code',
+    language: function language(_ref4) {
+      var _values$get$find, _values$get$find$toLo;
+      var values = _ref4.values;
+      return getLanguageFromContentType((_values$get$find = values.get('headers').find(function (_, header) {
+        return (header === null || header === void 0 ? void 0 : header.toLowerCase()) === 'content-type';
+      })) === null || _values$get$find === void 0 ? void 0 : (_values$get$find$toLo = _values$get$find.toLowerCase) === null || _values$get$find$toLo === void 0 ? void 0 : _values$get$find$toLo.call(_values$get$find));
+    },
+    initialValue: (0, _immutable.getIn)(config, ['body', 'raw']),
+    visible: function visible(_ref5) {
+      var values = _ref5.values;
+      return values.get('body.bodyType') === 'raw';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }, {
+    name: '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)(config, ['body', 'parts'], (0, _immutable.List)()),
+    visible: function visible(_ref6) {
+      var values = _ref6.values;
+      return values.get('body.bodyType') === 'multipart_form';
+    },
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }];
+};
+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/operation/config_fields/sql.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeSQLOperationConfigFields = exports.generatePostgresOperationConfigFields = exports.generateMSSQLOperationConfigFields = void 0;
+var _immutable = require("immutable");
+var _integrationTypes = _interopRequireDefault(require("../../integrationTypes"));
+var serializeSQLOperationConfigFields = exports.serializeSQLOperationConfigFields = function serializeSQLOperationConfigFields(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 the value into the correct structure
+        return serialization.setIn(name.split('.'), values.get(name));
+      }
+      return serialization;
+    }, (0, _immutable.Map)());
+  };
+};
+var generatePostgresOperationConfigFields = exports.generatePostgresOperationConfigFields = function generatePostgresOperationConfigFields(config) {
+  return [{
+    name: 'configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: 'postgres',
+    required: true,
+    enabled: false
+  }, {
+    name: 'statement',
+    label: 'Query',
+    type: 'code',
+    language: 'postgresql',
+    initialValue: (0, _immutable.get)(config, 'statement'),
+    required: true
+  }, {
+    name: 'parameters',
+    label: 'Query Parameters',
+    type: 'text-multi',
+    initialValue: (0, _immutable.get)(config, 'parameters'),
+    placeholder: 'Value',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }];
+};
+var generateMSSQLOperationConfigFields = exports.generateMSSQLOperationConfigFields = function generateMSSQLOperationConfigFields(config) {
+  return [{
+    name: 'configType',
+    label: 'Type',
+    type: 'select',
+    options: _integrationTypes["default"],
+    initialValue: 'mssql',
+    required: true,
+    enabled: false
+  }, {
+    name: 'statement',
+    label: 'Query',
+    type: 'code',
+    language: 'mssql',
+    initialValue: (0, _immutable.get)(config, 'statement'),
+    required: true
+  }, {
+    name: 'parameters',
+    label: 'Query Parameters',
+    type: 'map',
+    initialValue: (0, _immutable.get)(config, 'parameters'),
+    placeholder: 'Key',
+    helpText: /*#__PURE__*/React.createElement(React.Fragment, null, "Use the ", /*#__PURE__*/React.createElement("code", null, '{{parameter}}'), " format to create dynamic parameters.")
+  }];
+};

package/lib/components/system/SystemSecurityForm.js

@@ -55,7 +55,7 @@ var fields = function fields() {
       }
     }, {
       name: 'allowedSystemIpsEnabled',
-      label: 'Enabled Allowed IP Restrictions?',
+      label: 'Allowed IP Restrictions',
       type: 'checkbox',
       initialValue: (0, _immutable.get)(systemSecurity, 'allowedSystemIps', (0, _immutable.List)()).size > 0,
       "transient": true

package/lib/components/system/SystemTaskAdapterForm.js

@@ -14,8 +14,8 @@ var _immutable = require("immutable");
 var _Form2 = require("../form/Form.helpers");
 var dataSources = function dataSources() {
   return {
-    defaultTaskDbAdapter: {
-      fn: _system.fetchSystemDefaultTaskDbAdapter,
+    defaultSQLDatabaseAdapter: {
+      fn: _system.fetchSystemDefaultSQLDbAdapter,
       params: [],
       transform: function transform(result) {
         return result.adapter;
@@ -45,9 +45,9 @@ var handleSubmit = function handleSubmit() {
     };
     var adapter = {
       type: type,
-      properties: (0, _helpers.adapterProperties)(values, type, filterFn)
+      properties: (0, _helpers.adapterProperties)(values, null, type, filterFn)
     };
-    return (0, _system.updateSystemDefaultTaskDbAdapter)({
+    return (0, _system.updateSystemDefaultSQLDbAdapter)({
       adapter: adapter,
       multipart: Object.entries(adapter.properties).some(function (_ref2) {
         var _ref3 = (0, _slicedToArray2["default"])(_ref2, 2),
@@ -60,14 +60,14 @@ var handleSubmit = function handleSubmit() {
 };
 var fields = function fields() {
   return function (_ref4) {
-    var defaultTaskDbAdapter = _ref4.defaultTaskDbAdapter;
-    return (defaultTaskDbAdapter || defaultTaskDbAdapter === null) && [{
+    var defaultSQLDatabaseAdapter = _ref4.defaultSQLDatabaseAdapter;
+    return (defaultSQLDatabaseAdapter || defaultSQLDatabaseAdapter === null) && [{
       name: 'type',
-      label: 'Task Adapter',
+      label: 'Database Adapter',
       type: 'select',
       options: _helpers.VALIDATE_DB_ADAPTERS,
-      initialValue: (0, _immutable.getIn)(defaultTaskDbAdapter, ['type'], '')
-    }].concat((0, _toConsumableArray2["default"])((0, _helpers.MSSQL_FIELDS)('type', defaultTaskDbAdapter, [], null)), (0, _toConsumableArray2["default"])((0, _helpers.ORACLE_FIELDS)('type', defaultTaskDbAdapter, [], null)), (0, _toConsumableArray2["default"])((0, _helpers.POSTGRES_FIELDS)('type', defaultTaskDbAdapter, [], null)));
+      initialValue: (0, _immutable.getIn)(defaultSQLDatabaseAdapter, ['type'], '')
+    }].concat((0, _toConsumableArray2["default"])((0, _helpers.MSSQL_FIELDS)('type', defaultSQLDatabaseAdapter, [], null)), (0, _toConsumableArray2["default"])((0, _helpers.ORACLE_FIELDS)('type', defaultSQLDatabaseAdapter, [], null)), (0, _toConsumableArray2["default"])((0, _helpers.POSTGRES_FIELDS)('type', defaultSQLDatabaseAdapter, [], null)));
   };
 };
 var SystemTaskAdapterForm = exports.SystemTaskAdapterForm = (0, _Form.generateForm)({

package/lib/components/system/SystemUserForm.js

@@ -35,6 +35,8 @@ var fields = function fields() {
       label: 'Username',
       type: 'text',
       required: true,
+      pattern: /^[^/&?=:%]*$/,
+      patternMessage: 'The characters / & ? = : % are not allowed.',
       initialValue: (0, _immutable.get)(user, 'username') || ''
     }, {
       name: 'password',