@webiny/app-aco 5.36.2 → 5.37.0-beta.1

package/contexts/records.js

@@ -6,19 +6,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SearchRecordsProvider = exports.SearchRecordsContext = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _objectSpread18 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _react = _interopRequireWildcard(require("react"));
-var _reactHooks = require("@apollo/react-hooks");
+var _dotPropImmutable = _interopRequireDefault(require("dot-prop-immutable"));
 var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
 var _unionBy = _interopRequireDefault(require("lodash/unionBy"));
 var _handlers = require("../handlers");
 var _records = require("../graphql/records.gql");
 var _sorting = require("../sorting");
+var _hooks = require("../hooks");
+var _utils = require("@webiny/utils");
 var SearchRecordsContext = /*#__PURE__*/_react.default.createContext(undefined);
 exports.SearchRecordsContext = SearchRecordsContext;
 var defaultLoading = {
@@ -26,10 +27,37 @@ var defaultLoading = {
   LIST: false,
   LIST_MORE: false,
   GET: false,
+  MOVE: false,
   CREATE: false,
   UPDATE: false,
   DELETE: false
 };
+var mergeRecords = function mergeRecords(oldRecords, newRecords) {
+  if (!newRecords.length) {
+    return oldRecords;
+  }
+  var mergedRecords = newRecords.reduce(function (items, record) {
+    var index = items.findIndex(function (item) {
+      return item.id === record.id;
+    });
+    if (index === -1) {
+      items.push(record);
+      return items;
+    }
+    items[index] = record;
+    return items;
+  }, (0, _toConsumableArray2.default)(oldRecords)); // merge the two arrays
+
+  return (0, _sortBy.default)(mergedRecords, ["title"]);
+};
+var getRecordCount = function getRecordCount(records, folderIdPath, folderId) {
+  if (!folderId) {
+    return records.length;
+  }
+  return records.filter(function (record) {
+    return _dotPropImmutable.default.get(record, folderIdPath) === folderId;
+  }).length;
+};
 var mergeAndSortTags = function mergeAndSortTags(oldTagItems, newTags) {
   if (!newTags.length) {
     return oldTagItems;
@@ -43,14 +71,31 @@ var mergeAndSortTags = function mergeAndSortTags(oldTagItems, newTags) {
 
   return (0, _sortBy.default)(mergedTagItems, ["tag"]);
 };
+var getResponseData = function getResponseData(response, mode) {
+  var _response$search;
+  if (mode === "cms") {
+    return (response === null || response === void 0 ? void 0 : response.content) || {};
+  }
+  return ((_response$search = response.search) === null || _response$search === void 0 ? void 0 : _response$search.content) || {};
+};
+var defaultMeta = {
+  totalCount: 0,
+  hasMoreItems: false,
+  cursor: null
+};
 var SearchRecordsProvider = function SearchRecordsProvider(_ref) {
   var children = _ref.children;
-  var client = (0, _reactHooks.useApolloClient)();
-  var _useState = (0, _react.useState)(Object.create(null)),
+  var _useAcoApp = (0, _hooks.useAcoApp)(),
+    app = _useAcoApp.app,
+    client = _useAcoApp.client,
+    mode = _useAcoApp.mode,
+    folderIdPath = _useAcoApp.folderIdPath;
+  var model = app.model;
+  var _useState = (0, _react.useState)([]),
     _useState2 = (0, _slicedToArray2.default)(_useState, 2),
     records = _useState2[0],
     setRecords = _useState2[1];
-  var _useState3 = (0, _react.useState)(Object.create(null)),
+  var _useState3 = (0, _react.useState)([]),
     _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
     tags = _useState4[0],
     setTags = _useState4[1];
@@ -58,417 +103,513 @@ var SearchRecordsProvider = function SearchRecordsProvider(_ref) {
     _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
     loading = _useState6[0],
     setLoading = _useState6[1];
-  var _useState7 = (0, _react.useState)(Object.create(null)),
+  var _useState7 = (0, _react.useState)(Object.create(defaultMeta)),
     _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
     meta = _useState8[0],
     setMeta = _useState8[1];
-  var context = {
-    records: records,
-    tags: tags,
-    loading: loading,
-    meta: meta,
-    listRecords: function listRecords(params) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
-        var _meta;
-        var type, folderId, after, limit, sorting, search, createdBy, tags_in, tags_startsWith, tags_not_startsWith, AND, OR, recordsCount, totalCount, action, sort, _yield$apolloFetching, response, _response$search$list, data, responseMeta, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              type = params.type, folderId = params.folderId, after = params.after, limit = params.limit, sorting = params.sort, search = params.search, createdBy = params.createdBy, tags_in = params.tags_in, tags_startsWith = params.tags_startsWith, tags_not_startsWith = params.tags_not_startsWith, AND = params.AND, OR = params.OR;
-              /**
-               * Both folderId and type are optional to init `useRecords` but required to list records:
-               * this allows us to use `useRecords` methods like `getRecord` without passing useless params.
-               * But still, we need these params to list records.
-               */
-              if (type) {
-                _context.next = 3;
-                break;
-              }
-              throw new Error("`type` are mandatory");
-            case 3:
-              /**
-               * Avoiding to fetch records in case they have already been fetched.
-               * This happens when visiting a list with all records loaded and receives "after" param.
-               */
-              recordsCount = records[type] && records[type].filter(function (record) {
-                return record.location.folderId === folderId;
-              }).length;
-              totalCount = ((_meta = meta[folderId || "search"]) === null || _meta === void 0 ? void 0 : _meta.totalCount) || 0;
-              if (!(after && recordsCount === totalCount)) {
-                _context.next = 7;
-                break;
-              }
-              return _context.abrupt("return");
-            case 7:
-              // Remove records in case of sorting change and not a paginated request.
-              if (sorting && !after) {
-                setRecords(function (records) {
-                  return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, type, []));
-                });
-              }
-              action = after ? "LIST_MORE" : "LIST";
-              sort = (0, _sorting.validateOrGetDefaultDbSort)(sorting);
-              _context.next = 12;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)(action, setLoading), function () {
-                return client.query({
-                  query: _records.LIST_RECORDS,
-                  variables: {
-                    where: (0, _objectSpread18.default)((0, _objectSpread18.default)({
-                      type: type
-                    }, folderId && {
-                      location: {
-                        folderId: folderId
-                      }
-                    }), {}, {
-                      tags_in: tags_in,
-                      tags_startsWith: tags_startsWith,
-                      tags_not_startsWith: tags_not_startsWith,
-                      createdBy: createdBy,
-                      AND: AND,
-                      OR: OR
-                    }),
+  var _useMemo = (0, _react.useMemo)(function () {
+      return {
+        LIST_RECORDS: (0, _records.createListRecords)(model, mode),
+        UPDATE_RECORD: (0, _records.createUpdateRecord)(model, mode),
+        MOVE_RECORD: (0, _records.createMoveRecord)(model, mode),
+        GET_RECORD: (0, _records.createGetRecord)(model, mode),
+        LIST_TAGS: (0, _records.createListTags)(model, mode),
+        DELETE_RECORD: (0, _records.createDeleteRecord)(model, mode),
+        CREATE_RECORD: (0, _records.createCreateRecord)(model, mode)
+      };
+    }, [app.id, model.modelId]),
+    GET_RECORD = _useMemo.GET_RECORD,
+    LIST_RECORDS = _useMemo.LIST_RECORDS,
+    UPDATE_RECORD = _useMemo.UPDATE_RECORD,
+    MOVE_RECORD = _useMemo.MOVE_RECORD,
+    DELETE_RECORD = _useMemo.DELETE_RECORD,
+    CREATE_RECORD = _useMemo.CREATE_RECORD,
+    LIST_TAGS = _useMemo.LIST_TAGS;
+  var context = (0, _react.useMemo)(function () {
+    return {
+      records: records,
+      tags: tags,
+      loading: loading,
+      meta: meta,
+      addRecordToCache: function addRecordToCache(record) {
+        setRecords(function (prev) {
+          return [record].concat((0, _toConsumableArray2.default)(prev));
+        });
+      },
+      updateRecordInCache: function updateRecordInCache(record) {
+        var _parseIdentifier = (0, _utils.parseIdentifier)(record.id),
+          recordId = _parseIdentifier.id;
+        var index = records.findIndex(function (item) {
+          var _parseIdentifier2 = (0, _utils.parseIdentifier)(item.id),
+            itemId = _parseIdentifier2.id;
+          return itemId === recordId;
+        });
+        if (index === -1) {
+          return;
+        }
+        setRecords(function (prev) {
+          var next = (0, _toConsumableArray2.default)(prev);
+          next[index] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev[index]), record);
+          return next;
+        });
+      },
+      removeRecordFromCache: function removeRecordFromCache(id) {
+        setRecords(function (prev) {
+          return prev.filter(function (record) {
+            return record.id !== id;
+          });
+        });
+      },
+      listRecords: function listRecords(params) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+          var after, limit, sorting, search, where, folderId, recordsCount, totalCount, action, sort, _yield$apolloFetching, response, _getResponseData, data, responseMeta, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                after = params.after, limit = params.limit, sorting = params.sort, search = params.search, where = params.where;
+                folderId = _dotPropImmutable.default.get(where, folderIdPath);
+                /**
+                 * Avoiding to fetch records in case they have already been fetched.
+                 * This happens when visiting a list with all records loaded and receives "after" param.
+                 */
+                recordsCount = getRecordCount(records, folderIdPath, folderId);
+                totalCount = (meta === null || meta === void 0 ? void 0 : meta.totalCount) || 0;
+                if (!(after && recordsCount === totalCount)) {
+                  _context.next = 6;
+                  break;
+                }
+                return _context.abrupt("return", records);
+              case 6:
+                // Remove records in case of sorting change and not a paginated request.
+                if (sorting && !after) {
+                  setRecords([]);
+                }
+                action = after ? "LIST_MORE" : "LIST";
+                sort = (0, _sorting.validateOrGetDefaultDbSort)(sorting);
+                _context.next = 11;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)(action, setLoading), function () {
+                  var variables = {
+                    where: where,
                     search: search,
                     limit: limit,
                     after: after,
                     sort: sort
-                  },
-                  fetchPolicy: "network-only"
+                  };
+                  return client.query({
+                    query: LIST_RECORDS,
+                    variables: variables,
+                    fetchPolicy: "network-only"
+                  });
                 });
-              });
-            case 12:
-              _yield$apolloFetching = _context.sent;
-              response = _yield$apolloFetching.data;
-              _response$search$list = response.search.listRecords, data = _response$search$list.data, responseMeta = _response$search$list.meta, error = _response$search$list.error;
-              if (!(!data || !responseMeta)) {
-                _context.next = 17;
-                break;
-              }
-              throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not fetch records");
-            case 17:
-              setRecords(function (records) {
-                // In case of paginated request, we merge the fetched records with the existing ones, after sorting them.
-                if (after) {
-                  return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, type, (0, _sorting.sortTableItems)((0, _unionBy.default)(data, records[type], "id"), sort)));
+              case 11:
+                _yield$apolloFetching = _context.sent;
+                response = _yield$apolloFetching.data;
+                if (response) {
+                  _context.next = 15;
+                  break;
                 }
-
-                // Otherwise, we return the fetched records after sorting them.
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, type, (0, _sorting.sortTableItems)(data, sort)));
-              });
-              setMeta(function (meta) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, meta), {}, (0, _defineProperty2.default)({}, folderId || "search", responseMeta));
-              });
-              setLoading(function (prev) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, prev), {}, {
-                  INIT: false
+                throw new Error("Could not fetch records - no response.");
+              case 15:
+                _getResponseData = getResponseData(response, mode), data = _getResponseData.data, responseMeta = _getResponseData.meta, error = _getResponseData.error;
+                if (!(!data || !responseMeta)) {
+                  _context.next = 18;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not fetch records.");
+              case 18:
+                setRecords(function (prev) {
+                  /**
+                   * In case of paginated request, we merge the fetched records with the existing ones, and then sort them.
+                   * Otherwise, we sort the fetched records and set them as the new records.
+                   */
+                  return (0, _sorting.sortTableItems)(mergeRecords(after ? prev : [], data), sort);
                 });
-              });
-              return _context.abrupt("return", data);
-            case 21:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee);
-      }))();
-    },
-    getRecord: function getRecord(id) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
-        var _yield$apolloFetching2, response, _response$search$getR, data, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              if (id) {
-                _context2.next = 2;
-                break;
-              }
-              throw new Error("Record `id` is mandatory");
-            case 2:
-              _context2.next = 4;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("GET", setLoading), function () {
-                return client.query({
-                  query: _records.GET_RECORD,
-                  variables: {
-                    id: id
-                  },
-                  fetchPolicy: "network-only"
+                setMeta(function () {
+                  return responseMeta;
                 });
-              });
-            case 4:
-              _yield$apolloFetching2 = _context2.sent;
-              response = _yield$apolloFetching2.data;
-              _response$search$getR = response.search.getRecord, data = _response$search$getR.data, error = _response$search$getR.error;
-              if (!(error && error.code !== "NOT_FOUND")) {
-                _context2.next = 9;
-                break;
-              }
-              throw new Error("Network error while syncing record");
-            case 9:
-              if (!data) {
-                // No record found - must be deleted by previous operation
-                setRecords(function (records) {
-                  var currentRecord = Object.keys(records).reduce(function (accumulator, current) {
-                    return [].concat((0, _toConsumableArray2.default)(accumulator), (0, _toConsumableArray2.default)(records[current]));
-                  }, []).find(function (record) {
-                    return record.id === id;
+                setLoading(function (prev) {
+                  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev), {}, {
+                    INIT: false
                   });
-                  if (!currentRecord) {
-                    return records;
-                  }
-                  return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, currentRecord.type, records[currentRecord.type].filter(function (record) {
+                });
+                return _context.abrupt("return", data);
+              case 22:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }))();
+      },
+      getRecord: function getRecord(id) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
+          var _yield$apolloFetching2, response, _getResponseData2, data, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                if (id) {
+                  _context2.next = 2;
+                  break;
+                }
+                throw new Error("Record `id` is mandatory");
+              case 2:
+                _context2.next = 4;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("GET", setLoading), function () {
+                  return client.query({
+                    query: GET_RECORD,
+                    variables: {
+                      id: id
+                    },
+                    fetchPolicy: "network-only"
+                  });
+                });
+              case 4:
+                _yield$apolloFetching2 = _context2.sent;
+                response = _yield$apolloFetching2.data;
+                if (response) {
+                  _context2.next = 8;
+                  break;
+                }
+                throw new Error("Could not fetch record \"".concat(id, "\" - no response."));
+              case 8:
+                _getResponseData2 = getResponseData(response, mode), data = _getResponseData2.data, error = _getResponseData2.error;
+                if (!(error && error.code !== "NOT_FOUND")) {
+                  _context2.next = 11;
+                  break;
+                }
+                throw new Error("Network error while syncing record");
+              case 11:
+                if (data) {
+                  _context2.next = 14;
+                  break;
+                }
+                // No record found - must be deleted by previous operation
+                setRecords(function (prev) {
+                  return prev.filter(function (record) {
                     return record.id !== id;
-                  })));
+                  });
                 });
-              } else {
-                setRecords(function (prevRecords) {
-                  var prevRecordsByType = prevRecords[data.type];
-                  var recordIndex = prevRecordsByType.findIndex(function (record) {
+                return _context2.abrupt("return", data);
+              case 14:
+                setRecords(function (prev) {
+                  var index = prev.findIndex(function (record) {
                     return record.id === id;
                   });
 
                   // No record found in the list - must be added by previous operation
-                  if (recordIndex === -1) {
-                    return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, prevRecords), {}, (0, _defineProperty2.default)({}, data.type, [data].concat((0, _toConsumableArray2.default)(prevRecordsByType))));
+                  if (index === -1) {
+                    return [data].concat((0, _toConsumableArray2.default)(prev));
                   }
-
-                  // Updating record found in the list
-                  var result = (0, _objectSpread18.default)((0, _objectSpread18.default)({}, prevRecords), {}, (0, _defineProperty2.default)({}, data.type, [].concat((0, _toConsumableArray2.default)(prevRecordsByType.slice(0, recordIndex)), [(0, _objectSpread18.default)((0, _objectSpread18.default)({}, prevRecordsByType[recordIndex]), data)], (0, _toConsumableArray2.default)(prevRecordsByType.slice(recordIndex + 1)))));
-                  return result;
+                  var next = (0, _toConsumableArray2.default)(prev);
+                  next[index] = data;
+                  return next;
                 });
                 setTags(function (tags) {
                   if (!data.tags || data.tags.length === 0) {
                     return tags;
                   }
-                  var tagsByType = tags[data.type]; // get existing tags
-
-                  return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, tags), {}, (0, _defineProperty2.default)({}, data.type, mergeAndSortTags(tagsByType, data.tags)));
+                  return mergeAndSortTags(tags, data.tags);
+                });
+                return _context2.abrupt("return", data);
+              case 17:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }))();
+      },
+      createRecord: function createRecord(record) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3() {
+          var _yield$apolloFetching3, response, _getResponseData3, data, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                if (CREATE_RECORD) {
+                  _context3.next = 2;
+                  break;
+                }
+                throw new Error("Missing CREATE_RECORD operation.");
+              case 2:
+                _context3.next = 4;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("CREATE", setLoading), function () {
+                  return client.mutate({
+                    mutation: CREATE_RECORD,
+                    variables: {
+                      data: record
+                    }
+                  });
                 });
-              }
-              return _context2.abrupt("return", data);
-            case 11:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2);
-      }))();
-    },
-    createRecord: function createRecord(record) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3() {
-        var location, folderId, _yield$apolloFetching3, response, _response$search$crea, data, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              location = record.location;
-              folderId = location.folderId;
-              _context3.next = 4;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("CREATE", setLoading), function () {
-                return client.mutate({
-                  mutation: _records.CREATE_RECORD,
-                  variables: {
-                    data: record
+              case 4:
+                _yield$apolloFetching3 = _context3.sent;
+                response = _yield$apolloFetching3.data;
+                if (response) {
+                  _context3.next = 8;
+                  break;
+                }
+                throw new Error("Network error while creating search record.");
+              case 8:
+                _getResponseData3 = getResponseData(response, mode), data = _getResponseData3.data, error = _getResponseData3.error;
+                if (data) {
+                  _context3.next = 11;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not create record");
+              case 11:
+                setRecords(function (prev) {
+                  return [].concat((0, _toConsumableArray2.default)(prev), [data]);
+                });
+                setMeta(function (meta) {
+                  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, meta), {}, {
+                    totalCount: ++meta.totalCount
+                  });
+                });
+                setTags(function (tags) {
+                  if (!data.tags || data.tags.length === 0) {
+                    return tags;
                   }
+                  return mergeAndSortTags(tags, data.tags);
                 });
-              });
-            case 4:
-              _yield$apolloFetching3 = _context3.sent;
-              response = _yield$apolloFetching3.data;
-              if (response) {
-                _context3.next = 8;
-                break;
-              }
-              throw new Error("Network error while creating search record");
-            case 8:
-              _response$search$crea = response.search.createRecord, data = _response$search$crea.data, error = _response$search$crea.error;
-              if (data) {
-                _context3.next = 11;
-                break;
-              }
-              throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not create record");
-            case 11:
-              setRecords(function (records) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, data.type, [].concat((0, _toConsumableArray2.default)(records[data.type]), [data])));
-              });
-              setMeta(function (meta) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, meta), {}, (0, _defineProperty2.default)({}, folderId, (0, _objectSpread18.default)((0, _objectSpread18.default)({}, meta[folderId]), {}, {
-                  totalCount: ++meta[folderId].totalCount
-                })));
-              });
-              setTags(function (tags) {
-                if (!data.tags || data.tags.length === 0) {
-                  return tags;
+                return _context3.abrupt("return", data);
+              case 15:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3);
+        }))();
+      },
+      updateRecord: function updateRecord(record, contextFolderId) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4() {
+          var id, location, data, title, content, _yield$apolloFetching4, response, _getResponseData4, result, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
+            while (1) switch (_context4.prev = _context4.next) {
+              case 0:
+                if (contextFolderId) {
+                  _context4.next = 2;
+                  break;
                 }
-                var tagsByType = tags[data.type]; // get existing tags
-
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, tags), {}, (0, _defineProperty2.default)({}, data.type, mergeAndSortTags(tagsByType, data.tags)));
-              });
-              return _context3.abrupt("return", data);
-            case 15:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3);
-      }))();
-    },
-    updateRecord: function updateRecord(record, contextFolderId) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4() {
-        var id, location, data, title, content, type, _yield$apolloFetching4, response, _response$search$upda, result, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
-          while (1) switch (_context4.prev = _context4.next) {
-            case 0:
-              if (contextFolderId) {
-                _context4.next = 2;
-                break;
-              }
-              throw new Error("`folderId` is mandatory");
-            case 2:
-              id = record.id, location = record.location, data = record.data, title = record.title, content = record.content, type = record.type;
-              _context4.next = 5;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("UPDATE", setLoading), function () {
-                return client.mutate({
-                  mutation: _records.UPDATE_RECORD,
-                  variables: {
-                    id: id,
-                    data: {
-                      title: title,
-                      content: content,
-                      location: location,
-                      data: data
+                throw new Error("`folderId` is mandatory");
+              case 2:
+                if (UPDATE_RECORD) {
+                  _context4.next = 4;
+                  break;
+                }
+                throw new Error("Missing UPDATE_RECORD operation.");
+              case 4:
+                id = record.id, location = record.location, data = record.data, title = record.title, content = record.content;
+                _context4.next = 7;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("UPDATE", setLoading), function () {
+                  return client.mutate({
+                    mutation: UPDATE_RECORD,
+                    variables: {
+                      id: id,
+                      data: {
+                        title: title,
+                        content: content,
+                        location: location,
+                        data: data
+                      }
                     }
-                  }
+                  });
                 });
-              });
-            case 5:
-              _yield$apolloFetching4 = _context4.sent;
-              response = _yield$apolloFetching4.data;
-              if (response) {
-                _context4.next = 9;
-                break;
-              }
-              throw new Error("Network error while updating record");
-            case 9:
-              _response$search$upda = response.search.updateRecord, result = _response$search$upda.data, error = _response$search$upda.error;
-              if (result) {
-                _context4.next = 12;
-                break;
-              }
-              throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not update record");
-            case 12:
-              setRecords(function (records) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, type, records[type].map(function (record) {
-                  return record.id === id ? result : record;
-                }).filter(function (record) {
-                  return record.location.folderId === contextFolderId;
-                })));
-              });
-              setTags(function (tags) {
-                if (!data.tags || data.tags.length === 0) {
-                  return tags;
+              case 7:
+                _yield$apolloFetching4 = _context4.sent;
+                response = _yield$apolloFetching4.data;
+                if (response) {
+                  _context4.next = 11;
+                  break;
                 }
-                var tagsByType = tags[data.type]; // get existing tags
-
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, tags), {}, (0, _defineProperty2.default)({}, data.type, mergeAndSortTags(tagsByType, data.tags)));
-              });
-              return _context4.abrupt("return", result);
-            case 15:
-            case "end":
-              return _context4.stop();
-          }
-        }, _callee4);
-      }))();
-    },
-    deleteRecord: function deleteRecord(record) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee5() {
-        var id, location, type, folderId, _yield$apolloFetching5, response, _response$search$dele, data, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee5$(_context5) {
-          while (1) switch (_context5.prev = _context5.next) {
-            case 0:
-              id = record.id, location = record.location, type = record.type;
-              folderId = location.folderId;
-              _context5.next = 4;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("DELETE", setLoading), function () {
-                return client.mutate({
-                  mutation: _records.DELETE_RECORD,
-                  variables: {
-                    id: id
+                throw new Error("Network error while updating record");
+              case 11:
+                _getResponseData4 = getResponseData(response, mode), result = _getResponseData4.data, error = _getResponseData4.error;
+                if (result) {
+                  _context4.next = 14;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not update record");
+              case 14:
+                setRecords(function (records) {
+                  var index = records.findIndex(function (record) {
+                    return record.id === id;
+                  });
+                  if (index === -1) {
+                    return [result].concat((0, _toConsumableArray2.default)(records));
                   }
+                  var next = (0, _toConsumableArray2.default)(records);
+                  next[index] = result;
+                  return next;
                 });
-              });
-            case 4:
-              _yield$apolloFetching5 = _context5.sent;
-              response = _yield$apolloFetching5.data;
-              if (response) {
-                _context5.next = 8;
-                break;
-              }
-              throw new Error("Network error while deleting record");
-            case 8:
-              _response$search$dele = response.search.deleteRecord, data = _response$search$dele.data, error = _response$search$dele.error;
-              if (data) {
-                _context5.next = 11;
-                break;
-              }
-              throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not delete record");
-            case 11:
-              setRecords(function (records) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, records), {}, (0, _defineProperty2.default)({}, type, records[type].filter(function (record) {
-                  return record.id !== id;
-                })));
-              });
-              setMeta(function (meta) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, meta), {}, (0, _defineProperty2.default)({}, folderId, (0, _objectSpread18.default)((0, _objectSpread18.default)({}, meta[folderId]), {}, {
-                  totalCount: --meta[folderId].totalCount
-                })));
-              });
-              return _context5.abrupt("return", true);
-            case 14:
-            case "end":
-              return _context5.stop();
-          }
-        }, _callee5);
-      }))();
-    },
-    listTags: function listTags(params) {
-      return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee6() {
-        var type, _yield$apolloFetching6, response, _response$search$list2, data, error;
-        return (0, _regeneratorRuntime2.default)().wrap(function _callee6$(_context6) {
-          while (1) switch (_context6.prev = _context6.next) {
-            case 0:
-              type = params.type;
-              if (type) {
-                _context6.next = 3;
-                break;
-              }
-              throw new Error("`type` is mandatory");
-            case 3:
-              _context6.next = 5;
-              return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("LIST", setLoading), function () {
-                return client.query({
-                  query: _records.LIST_TAGS,
-                  variables: {
-                    where: params
+                setTags(function (tags) {
+                  if (!data.tags || data.tags.length === 0) {
+                    return tags;
                   }
+                  return mergeAndSortTags(tags, data.tags);
                 });
-              });
-            case 5:
-              _yield$apolloFetching6 = _context6.sent;
-              response = _yield$apolloFetching6.data;
-              _response$search$list2 = response.search.listTags, data = _response$search$list2.data, error = _response$search$list2.error;
-              if (data) {
-                _context6.next = 10;
-                break;
-              }
-              throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not fetch tags");
-            case 10:
-              setTags(function (tags) {
-                return (0, _objectSpread18.default)((0, _objectSpread18.default)({}, tags), {}, (0, _defineProperty2.default)({}, type, data));
-              });
-              return _context6.abrupt("return", data);
-            case 12:
-            case "end":
-              return _context6.stop();
-          }
-        }, _callee6);
-      }))();
-    }
-  };
+                return _context4.abrupt("return", result);
+              case 17:
+              case "end":
+                return _context4.stop();
+            }
+          }, _callee4);
+        }))();
+      },
+      moveRecord: function () {
+        var _moveRecord = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee5(record) {
+          var id, location, folderId, _yield$apolloFetching5, response, _getResponseData5, data, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee5$(_context5) {
+            while (1) switch (_context5.prev = _context5.next) {
+              case 0:
+                id = record.id, location = record.location;
+                folderId = location.folderId;
+                _context5.next = 4;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("MOVE", setLoading), function () {
+                  return client.mutate({
+                    mutation: MOVE_RECORD,
+                    variables: {
+                      id: id,
+                      folderId: folderId
+                    }
+                  });
+                });
+              case 4:
+                _yield$apolloFetching5 = _context5.sent;
+                response = _yield$apolloFetching5.data;
+                if (response) {
+                  _context5.next = 8;
+                  break;
+                }
+                throw new Error("Network error while moving record.");
+              case 8:
+                _getResponseData5 = getResponseData(response, mode), data = _getResponseData5.data, error = _getResponseData5.error;
+                if (data) {
+                  _context5.next = 11;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not move record.");
+              case 11:
+                setRecords(function (prev) {
+                  return prev.filter(function (record) {
+                    return record.id !== id;
+                  });
+                });
+                setMeta(function (meta) {
+                  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, meta), {}, {
+                    totalCount: --meta.totalCount
+                  });
+                });
+              case 13:
+              case "end":
+                return _context5.stop();
+            }
+          }, _callee5);
+        }));
+        function moveRecord(_x) {
+          return _moveRecord.apply(this, arguments);
+        }
+        return moveRecord;
+      }(),
+      deleteRecord: function deleteRecord(record) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee6() {
+          var id, _yield$apolloFetching6, response, _getResponseData6, data, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee6$(_context6) {
+            while (1) switch (_context6.prev = _context6.next) {
+              case 0:
+                if (DELETE_RECORD) {
+                  _context6.next = 2;
+                  break;
+                }
+                throw new Error("Missing DELETE_RECORD operation.");
+              case 2:
+                id = record.id;
+                _context6.next = 5;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("DELETE", setLoading), function () {
+                  return client.mutate({
+                    mutation: DELETE_RECORD,
+                    variables: {
+                      id: id
+                    }
+                  });
+                });
+              case 5:
+                _yield$apolloFetching6 = _context6.sent;
+                response = _yield$apolloFetching6.data;
+                if (response) {
+                  _context6.next = 9;
+                  break;
+                }
+                throw new Error("Network error while deleting record.");
+              case 9:
+                _getResponseData6 = getResponseData(response, mode), data = _getResponseData6.data, error = _getResponseData6.error;
+                if (data) {
+                  _context6.next = 12;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not delete record");
+              case 12:
+                setRecords(function (prev) {
+                  return prev.filter(function (record) {
+                    return record.id !== id;
+                  });
+                });
+                setMeta(function (meta) {
+                  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, meta), {}, {
+                    totalCount: --meta.totalCount
+                  });
+                });
+                return _context6.abrupt("return", true);
+              case 15:
+              case "end":
+                return _context6.stop();
+            }
+          }, _callee6);
+        }))();
+      },
+      listTags: function listTags(params) {
+        return (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee7() {
+          var _yield$apolloFetching7, response, _getResponseData7, data, error;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee7$(_context7) {
+            while (1) switch (_context7.prev = _context7.next) {
+              case 0:
+                if (LIST_TAGS) {
+                  _context7.next = 2;
+                  break;
+                }
+                throw new Error("Missing LIST_TAGS operation.");
+              case 2:
+                _context7.next = 4;
+                return (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("LIST", setLoading), function () {
+                  return client.query({
+                    query: LIST_TAGS,
+                    variables: {
+                      where: params.where
+                    }
+                  });
+                });
+              case 4:
+                _yield$apolloFetching7 = _context7.sent;
+                response = _yield$apolloFetching7.data;
+                if (response) {
+                  _context7.next = 8;
+                  break;
+                }
+                throw new Error("Network error while fetching tags.");
+              case 8:
+                _getResponseData7 = getResponseData(response, mode), data = _getResponseData7.data, error = _getResponseData7.error;
+                if (data) {
+                  _context7.next = 11;
+                  break;
+                }
+                throw new Error((error === null || error === void 0 ? void 0 : error.message) || "Could not fetch tags");
+              case 11:
+                setTags(data);
+                return _context7.abrupt("return", data);
+              case 13:
+              case "end":
+                return _context7.stop();
+            }
+          }, _callee7);
+        }))();
+      }
+    };
+  }, [app.id, model.modelId, records, setRecords, tags, meta, loading, GET_RECORD, LIST_RECORDS, UPDATE_RECORD, DELETE_RECORD, MOVE_RECORD, CREATE_RECORD, LIST_TAGS]);
   return /*#__PURE__*/_react.default.createElement(SearchRecordsContext.Provider, {
     value: context
   }, children);