@kineticdata/react 5.0.16 → 5.1.0

package/lib/components/core/submission/helpers.js

@@ -0,0 +1,95 @@
+import { fromJS, List, Range } from 'immutable';
+import { TIMELINES, MAX_PART_LENGTH } from '../../../helpers';
+export var getUsedFields = function getUsedFields(values, partIndex) {
+  var partType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'eq';
+  var equalities = List();
+
+  if (partType === 'eq' && partIndex === 0) {
+    equalities = List();
+  } else if (partType === 'eq' && partIndex === 1) {
+    equalities = List([values.get('op0-part')]);
+  } else if (partType === 'eq') {
+    equalities = Range(0, partIndex).map(function (i) {
+      return values.get("op".concat(i, "-part"));
+    }).toList().filter(function (f) {
+      return f !== '';
+    });
+  } else if (partType === 'range') {
+    var orders = Range(0, MAX_PART_LENGTH).map(function (i) {
+      return values.get("orderby".concat(i, "-part"));
+    }).toList().filter(function (f) {
+      return f !== '' && f !== values.get('range-part');
+    });
+    equalities = Range(0, MAX_PART_LENGTH).map(function (i) {
+      return values.get("op".concat(i, "-part"));
+    }).toList().concat(orders).filter(function (f) {
+      return f !== '';
+    });
+  } else if (partType === 'orderBy') {
+    var _orders;
+
+    if (partIndex === 0) {
+      _orders = List();
+    } else if (partIndex === 1) {
+      _orders = List([values.get('orderby0-part')]);
+    } else {
+      _orders = Range(0, partIndex).map(function (i) {
+        return values.get("orderby".concat(i, "-part"));
+      }).toList().filter(function (f) {
+        return f !== '';
+      });
+    }
+
+    equalities = Range(0, MAX_PART_LENGTH).map(function (i) {
+      return values.get("op".concat(i, "-part"));
+    }).toList().concat(_orders).filter(function (f) {
+      return f !== '';
+    });
+  }
+
+  return equalities;
+};
+export var availableParts = function availableParts(values, indexes, equalityFields) {
+  var partType = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'eq';
+  var remainingParts = indexes.map(function (index) {
+    return getRemainingParts(index.get('parts', List()), equalityFields);
+  });
+  var containsTimeline = equalityFields.some(function (index) {
+    return TIMELINES.includes(index);
+  });
+  var anyAtLast = remainingParts.some(function (index) {
+    return index && index.size === 0;
+  });
+  var rangePart = values.get('range-part');
+  var timelinesAvailable = anyAtLast && !containsTimeline ? TIMELINES : containsTimeline ? getRemainingParts(List([equalityFields.last()]), fromJS(TIMELINES)) : List();
+
+  if (partType === 'range') {
+    var rangeRemaining = remainingParts.filter(function (index) {
+      return index && index.size === 1;
+    });
+    return rangeRemaining.concat(rangePart && rangeRemaining.size === 0 && values.get('orderby0-part') && values.get('orderby0-part') !== rangePart ? List([]) : timelinesAvailable || List([]));
+  } else if (partType === 'orderBy') {
+    return (rangePart ? List([rangePart]) : remainingParts.filter(function (index) {
+      return index && index.size > 0;
+    }).map(function (index) {
+      return index.first();
+    })).concat(TIMELINES.includes(rangePart) ? List([rangePart]) : anyAtLast ? fromJS(TIMELINES) : equalityFields.size === 0 ? fromJS(TIMELINES) : List()).toSet().toList();
+  } else {
+    return remainingParts.filterNot(function (index) {
+      return !index || index.size === 0;
+    }).map(function (index) {
+      return index.first();
+    }).toSet().toList().filterNot(function (p) {
+      return TIMELINES.includes(p);
+    });
+  }
+};
+export var getRemainingParts = function getRemainingParts(src, dst) {
+  if (src.size === 0 && dst.size === 0) return List(); // If we're matching so far, and the are no more to compare it's a match.
+
+  if (src.size > 0 && dst.size === 0) return src; // If we're out of elements but there's more to match, it's not a match.
+
+  if (src.size === 0 && dst.size > 0) return List();
+  if (src.first() === dst.first()) return getRemainingParts(src.shift(), dst.shift());
+  return null;
+};

package/lib/components/core/submission/helpers.test.js

@@ -0,0 +1,96 @@
+import { List, Map, fromJS } from 'immutable';
+import { availableParts, getRemainingParts } from './helpers';
+var INDEX_A_B = fromJS({
+  name: 'values[A],values[B]',
+  parts: ['values[A]', 'values[B]']
+});
+var INDEX_A_C = fromJS({
+  name: 'values[A],values[C]',
+  parts: ['values[A]', 'values[C]']
+});
+var INDEX_A_B_C = fromJS({
+  name: 'values[A],values[B],values[C]',
+  parts: ['values[A]', 'values[B]', 'values[C]']
+});
+describe('submission filter helpers', function () {
+  var indexes;
+  var values;
+  beforeEach(function () {
+    values = Map({});
+    indexes = List([]);
+  });
+  describe('#getRemainingParts', function () {
+    test('empty sets match', function () {
+      var result = getRemainingParts(List(), List());
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(0);
+    });
+    test('when left is the same as right', function () {
+      var result = getRemainingParts(List([1]), List([1]));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(0);
+    });
+    test('when left is larger than right', function () {
+      var result = getRemainingParts(List([1, 2]), List([1]));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(1);
+      expect(result.first()).toBe(2);
+    });
+    test('when left is larger than right with multiple values', function () {
+      var result = getRemainingParts(List([1, 2, 3, 4]), List([1]));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(3);
+      expect(result.first()).toBe(2);
+    });
+    test('when left does not start with right', function () {
+      var result = getRemainingParts(List([2, 1]), List([1]));
+      expect(result).toBeNull();
+    });
+    test('when left does fully not start with right', function () {
+      var result = getRemainingParts(List([1, 1, 1]), List([1, 2]));
+      expect(result).toBeNull();
+    });
+    test('when left contains but does not start with right', function () {
+      var result = getRemainingParts(List([1, 1, 2]), List([1, 2]));
+      expect(result).toBeNull();
+    });
+  });
+  describe('#avaialbleParts', function () {
+    test('when there are no indexes', function () {
+      var result = availableParts(values, indexes, List(['values[A]', 'values[B]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(0);
+    });
+    test('when there are no indexes with parts remaining', function () {
+      var result = availableParts(values, indexes.push(INDEX_A_B), List(['values[A]', 'values[B]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(0);
+    });
+    test('when there are fewer parts', function () {
+      // We're expecting parts from `values[A],values[B]`
+      var result = availableParts(values, indexes.push(INDEX_A_B), List(['values[A]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(1);
+      expect(result.first()).toBe('values[B]');
+    });
+    test('when there are fewer parts in multiple indexes', function () {
+      var result = availableParts(values, indexes.push(INDEX_A_B).push(INDEX_A_C), List(['values[A]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(2);
+      expect(result.first()).toBe('values[B]');
+      expect(result.last()).toBe('values[C]');
+    });
+    test('when there are more parts in the index', function () {
+      var result = availableParts(values, indexes.push(INDEX_A_B_C), List(['values[A]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(1);
+      expect(result.first()).toBe('values[B]');
+    });
+    test('when multiple indexes start the same', function () {
+      var result = availableParts(values, indexes.push(INDEX_A_B).push(INDEX_A_B_C), List(['values[A]']));
+      expect(result).toBeImmutableList();
+      expect(result.size).toBe(1);
+      expect(result.first()).toBe('values[B]');
+    });
+  });
+});

package/lib/components/core/translation/ContextTable.js

@@ -50,7 +50,7 @@ var filters = function filters() {
       name: 'context',
       label: 'Context Type',
       type: 'select',
-      options: ['Kapp', 'Datastore', 'Custom'].map(function (el) {
+      options: ['Kapp', 'Custom'].map(function (el) {
         return {
           value: el,
           label: el === 'Kapp' ? 'Form' : el

package/lib/components/core/user/UserForm.js

@@ -2,8 +2,8 @@ import { get, List, Map } from 'immutable';
 import { generateForm } from '../../form/Form';
 import { createUser, fetchAttributeDefinitions, fetchUser, updateUser, fetchLocales, fetchTimezones } from '../../../apis';
 import { handleFormErrors } from '../../form/Form.helpers';
-var USER_INCLUDES = 'attributesMap,authorization,memberships,profileAttributesMap';
-var EMAIL_REGEX = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/;
+var USER_INCLUDES = 'details,attributesMap,authorization,memberships,profileAttributesMap';
+var EMAIL_REGEX = /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/i;
 
 var dataSources = function dataSources(_ref) {
   var username = _ref.username,

package/lib/components/core/webapi/WebApiForm.js

@@ -4,7 +4,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { generateForm } from '../../form/Form';
 import { get, Map } from 'immutable';
-import { fetchWebApi, createWebApi, updateWebApi, fetchSecurityPolicyDefinitions, fetchSpace, fetchTree, createTree, updateTree } from '../../../apis';
+import { createWebApi, updateWebApi, fetchSecurityPolicyDefinitions, createTree, updateTree, fetchSpace } from '../../../apis';
 export var WEB_API_METHODS = ['GET', 'POST', 'PUT', 'DELETE'];
 var securityEndpoints = {
   webApiExecution: {
@@ -15,136 +15,116 @@ var securityEndpoints = {
 };
 
 var dataSources = function dataSources(_ref) {
-  var slug = _ref.slug,
-      kappSlug = _ref.kappSlug;
+  var kappSlug = _ref.kappSlug,
+      webApi = _ref.webApi;
   return {
-    webApi: {
-      fn: fetchWebApi,
-      params: slug && [{
-        slug: slug,
-        kappSlug: kappSlug,
-        include: 'details,securityPolicies'
-      }],
-      transform: function transform(result) {
-        return result.webApi;
-      }
-    },
     securityPolicyDefinitions: {
       fn: fetchSecurityPolicyDefinitions,
-      params: kappSlug ? [{
-        kappSlug: kappSlug
+      params: kappSlug || webApi && webApi.get('kappSlug') ? [{
+        kappSlug: kappSlug || webApi && webApi.get('kappSlug')
       }] : [],
       transform: function transform(result) {
         return result.securityPolicyDefinitions;
       }
-    },
-    sourceName: {
-      fn: fetchSpace,
-      params: [{
-        include: 'platformComponents'
-      }],
-      transform: function transform(result) {
-        return result.space.platformComponents.task.config.platformSourceName;
-      }
-    },
-    sourceGroup: {
-      fn: function fn() {
-        return kappSlug ? "WebApis > ".concat(kappSlug) : 'WebApis';
-      },
-      params: []
-    },
-    tree: {
-      fn: fetchTree,
-      params: function params(_ref2) {
-        var sourceName = _ref2.sourceName,
-            sourceGroup = _ref2.sourceGroup,
-            webApi = _ref2.webApi;
-        return webApi && sourceName && [{
-          sourceName: sourceName,
-          sourceGroup: sourceGroup,
-          name: webApi.get('slug')
-        }];
-      },
-      transform: function transform(result) {
-        return result.error && result.error.notFound ? {} : result.tree;
-      }
     }
   };
 };
 
-var handleSubmit = function handleSubmit(_ref3) {
-  var slug = _ref3.slug,
-      kappSlug = _ref3.kappSlug;
+var handleSubmit = function handleSubmit(_ref2) {
+  var slug = _ref2.slug,
+      kappSlug = _ref2.kappSlug,
+      webApi = _ref2.webApi;
   return /*#__PURE__*/function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values, bindings) {
-      var sourceGroup, sourceName, tree, _yield, webApi, error, _yield$createTree, createTreeError, _yield$updateTree, updateTreeError;
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(values) {
+      var _yield$fetchSpace, space, sourceName, sourceGroup, _ref4, _webApi, error1, _ref5, tree, error2;
 
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              sourceGroup = bindings.sourceGroup, sourceName = bindings.sourceName, tree = bindings.tree;
+              if (webApi) {
+                _context.next = 38;
+                break;
+              }
+
               _context.next = 3;
-              return (slug ? updateWebApi : createWebApi)({
-                kappSlug: kappSlug,
-                slug: slug,
-                webApi: values.toJS(),
-                include: 'securityPolicies'
+              return fetchSpace({
+                include: 'platformComponents'
               });
 
             case 3:
-              _yield = _context.sent;
-              webApi = _yield.webApi;
-              error = _yield.error;
+              _yield$fetchSpace = _context.sent;
+              space = _yield$fetchSpace.space;
+              sourceName = space.platformComponents.task.config.platformSourceName;
+              sourceGroup = kappSlug ? "WebApis > ".concat(kappSlug) : 'WebApis';
 
-              if (!error) {
-                _context.next = 8;
+              if (!slug) {
+                _context.next = 13;
                 break;
               }
 
-              throw error.statusCode === 400 && error.message || 'There was an error saving the WebAPI';
+              _context.next = 10;
+              return updateWebApi({
+                kappSlug: kappSlug,
+                slug: slug,
+                webApi: values.toJS(),
+                include: 'securityPolicies'
+              });
 
-            case 8:
-              if (slug) {
-                _context.next = 17;
-                break;
-              }
+            case 10:
+              _context.t0 = _context.sent;
+              _context.next = 16;
+              break;
 
-              _context.next = 11;
-              return createTree({
-                tree: {
-                  sourceGroup: sourceGroup,
-                  sourceName: sourceName,
-                  name: values.get('slug')
-                }
+            case 13:
+              _context.next = 15;
+              return createWebApi({
+                kappSlug: kappSlug,
+                webApi: values.toJS(),
+                include: 'securityPolicies'
               });
 
-            case 11:
-              _yield$createTree = _context.sent;
-              createTreeError = _yield$createTree.error;
+            case 15:
+              _context.t0 = _context.sent;
+
+            case 16:
+              _ref4 = _context.t0;
+              _webApi = _ref4.webApi;
+              error1 = _ref4.error;
 
-              if (!createTreeError) {
-                _context.next = 15;
+              if (!error1) {
+                _context.next = 21;
                 break;
               }
 
-              throw createTreeError.statusCode === 400 && createTreeError.message || 'There was an error creating the WebAPI tree';
-
-            case 15:
-              _context.next = 24;
-              break;
+              throw error1.statusCode === 400 && error1.message || 'There was an error saving the WebAPI';
 
-            case 17:
-              if (!(!tree.isEmpty() && slug !== values.get('slug'))) {
-                _context.next = 24;
+            case 21:
+              if (!slug) {
+                _context.next = 27;
                 break;
               }
 
-              _context.next = 20;
+              _context.next = 24;
               return updateTree({
                 sourceName: sourceName,
                 sourceGroup: sourceGroup,
                 name: slug,
+                tree: {
+                  sourceName: sourceName,
+                  sourceGroup: sourceGroup,
+                  name: values.get('slug')
+                }
+              });
+
+            case 24:
+              _context.t1 = _context.sent;
+              _context.next = 30;
+              break;
+
+            case 27:
+              _context.next = 29;
+              return createTree({
                 tree: {
                   sourceGroup: sourceGroup,
                   sourceName: sourceName,
@@ -152,21 +132,31 @@ var handleSubmit = function handleSubmit(_ref3) {
                 }
               });
 
-            case 20:
-              _yield$updateTree = _context.sent;
-              updateTreeError = _yield$updateTree.error;
+            case 29:
+              _context.t1 = _context.sent;
+
+            case 30:
+              _ref5 = _context.t1;
+              tree = _ref5.tree;
+              error2 = _ref5.error;
 
-              if (!updateTreeError) {
-                _context.next = 24;
+              if (!error2) {
+                _context.next = 35;
                 break;
               }
 
-              throw updateTreeError.statusCode === 400 && updateTreeError.message || 'There was an error updating the WebAPI tree';
+              throw error2.statusCode === 400 && error2.message || 'There was an error saving the WebAPI tree';
 
-            case 24:
-              return _context.abrupt("return", webApi);
+            case 35:
+              return _context.abrupt("return", {
+                tree: tree,
+                webApi: _webApi
+              });
+
+            case 38:
+              return _context.abrupt("return", values.toObject());
 
-            case 25:
+            case 39:
             case "end":
               return _context.stop();
           }
@@ -174,18 +164,17 @@ var handleSubmit = function handleSubmit(_ref3) {
       }, _callee);
     }));
 
-    return function (_x, _x2) {
-      return _ref4.apply(this, arguments);
+    return function (_x) {
+      return _ref3.apply(this, arguments);
     };
   }();
 };
 
-var fields = function fields(_ref5) {
-  var slug = _ref5.slug;
-  return function (_ref6) {
-    var tree = _ref6.tree,
-        webApi = _ref6.webApi;
-    return (!slug || webApi && tree) && [{
+var fields = function fields(_ref6) {
+  var webApi = _ref6.webApi;
+  return function (_ref7) {
+    var securityPolicyDefinitions = _ref7.securityPolicyDefinitions;
+    return securityPolicyDefinitions && [{
       name: 'slug',
       label: 'Slug',
       type: 'text',
@@ -203,17 +192,17 @@ var fields = function fields(_ref5) {
         };
       }),
       initialValue: get(webApi, 'method') || ''
-    }].concat(_toConsumableArray(Object.entries(securityEndpoints).map(function (_ref7) {
-      var _ref8 = _slicedToArray(_ref7, 2),
-          endpointFieldName = _ref8[0],
-          endpoint = _ref8[1];
+    }].concat(_toConsumableArray(Object.entries(securityEndpoints).map(function (_ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+          endpointFieldName = _ref9[0],
+          endpoint = _ref9[1];
 
       return {
         name: endpointFieldName,
         label: endpoint.label,
         type: 'select',
-        options: function options(_ref9) {
-          var securityPolicyDefinitions = _ref9.securityPolicyDefinitions;
+        options: function options(_ref10) {
+          var securityPolicyDefinitions = _ref10.securityPolicyDefinitions;
           return securityPolicyDefinitions ? securityPolicyDefinitions.filter(function (definition) {
             return endpoint.types.includes(definition.get('type'));
           }).map(function (definition) {
@@ -233,20 +222,16 @@ var fields = function fields(_ref5) {
       label: 'Security Policies',
       type: null,
       visible: false,
-      serialize: function serialize(_ref10) {
-        var values = _ref10.values;
-        return Object.entries(securityEndpoints).map(function (_ref11) {
-          var _ref12 = _slicedToArray(_ref11, 2),
-              endpointFieldName = _ref12[0],
-              policy = _ref12[1];
-
-          return {
+      serialize: function serialize(_ref11) {
+        var values = _ref11.values;
+        return Map(securityEndpoints).map(function (policy, endpointFieldName) {
+          return Map({
             endpoint: policy.endpoint,
             name: values.get(endpointFieldName)
-          };
-        }).filter(function (endpoint) {
-          return endpoint.name !== '';
-        });
+          });
+        }).valueSeq().filter(function (policy) {
+          return policy.get('name') !== '';
+        }).toList();
       },
       initialValue: get(webApi, 'securityPolicies')
     }]);
@@ -254,7 +239,7 @@ var fields = function fields(_ref5) {
 };
 
 export var WebApiForm = generateForm({
-  formOptions: ['slug', 'kappSlug'],
+  formOptions: ['kappSlug', 'slug', 'webApi'],
   dataSources: dataSources,
   fields: fields,
   handleSubmit: handleSubmit

package/lib/components/core/webhook/WebhookForm.js

@@ -2,7 +2,7 @@ import { List, Map } from 'immutable';
 import { createWebhook, fetchWebhook, fetchKapp, fetchKappWebhookEvents, fetchSpace, fetchSpaceWebhookEvents, updateWebhook } from '../../../apis';
 import { generateForm } from '../../form/Form';
 import { buildBindings } from '../../../helpers';
-var SPACE_INCLUDES = 'datastoreFormAttributeDefinitions,spaceAttributeDefinitions,teamAttributeDefinitions,userAttributeDefinitions,userProfileAttributeDefinitions';
+var SPACE_INCLUDES = 'formAttributeDefinitions,spaceAttributeDefinitions,teamAttributeDefinitions,userAttributeDefinitions,userProfileAttributeDefinitions';
 var KAPP_INCLUDES = 'formAttributeDefinitions,kappAttributeDefinitions,fields';
 
 var dataSources = function dataSources(_ref) {

package/lib/components/form/Form.helpers.js

@@ -257,7 +257,7 @@ export var getFieldComponentProps = function getFieldComponentProps(field, readO
     onBlur: field.eventHandlers.get('onBlur'),
     onChange: field.eventHandlers.get('onChange'),
     onFocus: field.eventHandlers.get('onFocus'),
-    options: ['attributes', 'code', 'form', 'form-multi', 'map', 'radio', 'select', 'select-multi', 'table', 'text', 'text-multi'].includes(field.type) ? field.options : undefined,
+    options: ['attributes', 'checkbox-multi', 'code', 'form', 'form-multi', 'map', 'radio', 'select', 'select-multi', 'table', 'text', 'text-multi'].includes(field.type) ? field.options : undefined,
     placeholder: field.placeholder,
     renderAttributes: field.renderAttributes,
     required: field.required,