@webiny/app-aco 6.0.0-beta.0 → 6.0.0-rc.1

package/contexts/records.js

@@ -1,26 +1,15 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SearchRecordsProvider = exports.SearchRecordsContext = void 0;
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _react = _interopRequireWildcard(require("react"));
-var _sortBy = _interopRequireDefault(require("lodash/sortBy"));
-var _unionBy = _interopRequireDefault(require("lodash/unionBy"));
-var _merge = _interopRequireDefault(require("lodash/merge"));
-var _handlers = require("../handlers");
-var _records = require("../graphql/records.gql");
-var _sorting = require("../sorting");
-var _hooks = require("../hooks");
-var _utils = require("@webiny/utils");
-var _appAdmin = require("@webiny/app-admin");
-var SearchRecordsContext = exports.SearchRecordsContext = /*#__PURE__*/_react.default.createContext(undefined);
-var defaultLoading = {
+import React, { useMemo } from "react";
+import sortBy from "lodash/sortBy.js";
+import unionBy from "lodash/unionBy.js";
+import lodashMerge from "lodash/merge.js";
+import { apolloFetchingHandler, loadingHandler } from "../handlers.js";
+import { createGetRecord, createListRecords, createMoveRecord } from "../graphql/records.gql.js";
+import { validateOrGetDefaultDbSort } from "../sorting.js";
+import { useAcoApp } from "../hooks/index.js";
+import { parseIdentifier } from "@webiny/utils";
+import { useStateIfMounted } from "@webiny/app-admin";
+export const SearchRecordsContext = /*#__PURE__*/React.createContext(undefined);
+const defaultLoading = {
   INIT: true,
   LIST: false,
   LIST_MORE: false,
@@ -30,213 +19,223 @@ var defaultLoading = {
   UPDATE: false,
   DELETE: false
 };
-var mergeAndSortTags = function mergeAndSortTags(oldTagItems, newTags) {
+const mergeAndSortTags = (oldTagItems, newTags) => {
   if (!newTags.length) {
     return oldTagItems;
   }
-  var newTagItems = newTags.map(function (tag) {
-    return {
-      tag: tag
-    };
-  }); // create TagItem[] from array of strings
-  var mergedTagItems = (0, _unionBy.default)(oldTagItems, newTagItems, "tag"); // merge the two arrays
+  const newTagItems = newTags.map(tag => ({
+    tag
+  })); // create TagItem[] from array of strings
+  const mergedTagItems = unionBy(oldTagItems, newTagItems, "tag"); // merge the two arrays
 
-  return (0, _sortBy.default)(mergedTagItems, ["tag"]);
+  return sortBy(mergedTagItems, ["tag"]);
 };
-var getResponseData = function getResponseData(response, mode) {
-  if (mode === "cms") {
-    return response?.content || {};
-  }
-  return response.search?.content || {};
+const getResponseData = response => {
+  return response?.content || {};
 };
-var defaultMeta = {
+const defaultMeta = {
   totalCount: 0,
   hasMoreItems: false,
   cursor: null
 };
-var SearchRecordsProvider = exports.SearchRecordsProvider = function SearchRecordsProvider(_ref) {
-  var children = _ref.children;
-  var _useAcoApp = (0, _hooks.useAcoApp)(),
-    app = _useAcoApp.app,
-    client = _useAcoApp.client,
-    mode = _useAcoApp.mode;
-  var model = app.model;
-  var _useStateIfMounted = (0, _appAdmin.useStateIfMounted)([]),
-    _useStateIfMounted2 = (0, _slicedToArray2.default)(_useStateIfMounted, 2),
-    records = _useStateIfMounted2[0],
-    setRecords = _useStateIfMounted2[1];
-  var _useStateIfMounted3 = (0, _appAdmin.useStateIfMounted)([]),
-    _useStateIfMounted4 = (0, _slicedToArray2.default)(_useStateIfMounted3, 2),
-    tags = _useStateIfMounted4[0],
-    setTags = _useStateIfMounted4[1];
-  var _useStateIfMounted5 = (0, _appAdmin.useStateIfMounted)(defaultLoading),
-    _useStateIfMounted6 = (0, _slicedToArray2.default)(_useStateIfMounted5, 2),
-    loading = _useStateIfMounted6[0],
-    setLoading = _useStateIfMounted6[1];
-  var _useStateIfMounted7 = (0, _appAdmin.useStateIfMounted)(Object.create(defaultMeta)),
-    _useStateIfMounted8 = (0, _slicedToArray2.default)(_useStateIfMounted7, 2),
-    meta = _useStateIfMounted8[0],
-    setMeta = _useStateIfMounted8[1];
-  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 () {
+export const SearchRecordsProvider = ({
+  columns,
+  children
+}) => {
+  const {
+    app,
+    client
+  } = useAcoApp();
+  const {
+    model
+  } = app;
+
+  /**
+   * Retrieve all `fieldIds` from the ACO configuration, considering field `name`:
+   * The result is a deduplicated flat array of unique field IDs.
+   */
+  const fieldIds = columns.map(config => config.name).filter(Boolean);
+  const [records, setRecords] = useStateIfMounted([]);
+  const [tags, setTags] = useStateIfMounted([]);
+  const [loading, setLoading] = useStateIfMounted(defaultLoading);
+  const [meta, setMeta] = useStateIfMounted(Object.create(defaultMeta));
+  const {
+    GET_RECORD,
+    LIST_RECORDS,
+    UPDATE_RECORD,
+    MOVE_RECORD,
+    DELETE_RECORD,
+    CREATE_RECORD,
+    LIST_TAGS
+  } = useMemo(() => {
+    return {
+      LIST_RECORDS: createListRecords(model, fieldIds),
+      UPDATE_RECORD: null,
+      MOVE_RECORD: createMoveRecord(model),
+      GET_RECORD: createGetRecord(model),
+      LIST_TAGS: null,
+      DELETE_RECORD: null,
+      CREATE_RECORD: null
+    };
+  }, [app.model.modelId, fieldIds]);
+  const context = useMemo(() => {
     return {
-      records: records,
-      tags: tags,
-      loading: loading,
-      meta: meta,
-      addRecordToCache: function addRecordToCache(record) {
-        setRecords(function (prev) {
-          return [record].concat((0, _toConsumableArray2.default)(prev));
+      records,
+      tags,
+      loading,
+      meta,
+      addRecordToCache: record => {
+        setRecords(prev => {
+          return [record, ...prev];
         });
+        setMeta(meta => ({
+          ...meta,
+          totalCount: ++meta.totalCount
+        }));
       },
-      updateRecordInCache: function updateRecordInCache(record) {
-        var _parseIdentifier = (0, _utils.parseIdentifier)(record.id),
-          recordId = _parseIdentifier.id;
-        setRecords(function (prev) {
-          var index = prev.findIndex(function (item) {
-            var _parseIdentifier2 = (0, _utils.parseIdentifier)(item.id),
-              itemId = _parseIdentifier2.id;
+      updateRecordInCache: record => {
+        const {
+          id: recordId
+        } = parseIdentifier(record.id);
+        setRecords(prev => {
+          const index = prev.findIndex(item => {
+            const {
+              id: itemId
+            } = parseIdentifier(item.id);
             return itemId === recordId;
           });
           if (index >= 0) {
-            var next = (0, _toConsumableArray2.default)(prev);
-            next[index] = (0, _merge.default)({}, prev[index], record);
+            const next = [...prev];
+            next[index] = lodashMerge({}, prev[index], record);
             return next;
           }
-          return [record].concat((0, _toConsumableArray2.default)(prev));
+          return [record, ...prev];
         });
       },
-      removeRecordFromCache: function removeRecordFromCache(id) {
-        setRecords(function (prev) {
-          return prev.filter(function (record) {
-            return record.id !== id && !record.id.startsWith("".concat(id, "#"));
-          });
+      removeRecordFromCache: id => {
+        setRecords(prev => {
+          return prev.filter(record => record.id !== id && !record.id.startsWith(`${id}#`));
         });
+        setMeta(meta => ({
+          ...meta,
+          totalCount: --meta.totalCount
+        }));
       },
-      listRecords: async function listRecords(params) {
-        var after = params.after,
-          limit = params.limit,
-          sorting = params.sort,
-          search = params.search,
-          where = params.where;
+      async listRecords(params) {
+        const {
+          after,
+          limit,
+          sort: sorting,
+          search,
+          where
+        } = params;
 
         /**
          * Avoiding fetching records in case they have already been fetched.
          * This happens when visiting a list with all records loaded and receives "after" param.
          */
-        var totalCount = meta?.totalCount || 0;
+        const totalCount = meta?.totalCount || 0;
         if (after && records.length === totalCount) {
           return records;
         }
-        var action = after ? "LIST_MORE" : "LIST";
-        var sort = (0, _sorting.validateOrGetDefaultDbSort)(sorting);
-        var _await$apolloFetching = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)(action, setLoading), function () {
-            var variables = {
-              where: where,
-              search: search,
-              limit: limit,
-              after: after,
-              sort: sort
-            };
-            return client.query({
-              query: LIST_RECORDS,
-              variables: variables,
-              fetchPolicy: "network-only"
-            });
-          }),
-          response = _await$apolloFetching.data;
+        const action = after ? "LIST_MORE" : "LIST";
+        const sort = validateOrGetDefaultDbSort(sorting);
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler(action, setLoading), () => {
+          const variables = {
+            where,
+            search,
+            limit,
+            after,
+            sort
+          };
+          return client.query({
+            query: LIST_RECORDS,
+            variables,
+            fetchPolicy: "network-only"
+          });
+        });
         if (!response) {
           throw new Error("Could not fetch records - no response.");
         }
-        var _getResponseData = getResponseData(response, mode),
-          data = _getResponseData.data,
-          responseMeta = _getResponseData.meta,
-          error = _getResponseData.error;
+        const {
+          data,
+          meta: responseMeta,
+          error
+        } = getResponseData(response);
         if (!data || !responseMeta) {
           throw new Error(error?.message || "Could not fetch records.");
         }
-        setRecords(function (prev) {
+        setRecords(prev => {
           // If there's no cursor, it means we're receiving a new list of records from scratch.
           if (!after) {
             return data;
           }
-          return [].concat((0, _toConsumableArray2.default)(prev), (0, _toConsumableArray2.default)(data));
+          return [...prev, ...data];
         });
-        setMeta(function () {
-          return responseMeta;
-        });
-        setLoading(function (prev) {
-          return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, prev), {}, {
+        setMeta(() => responseMeta);
+        setLoading(prev => {
+          return {
+            ...prev,
             INIT: false
-          });
+          };
         });
         return data;
       },
-      getRecord: async function getRecord(id) {
+      async getRecord(id) {
         if (!id) {
           throw new Error("Record `id` is mandatory");
         }
-        var _parseIdentifier3 = (0, _utils.parseIdentifier)(id),
-          recordId = _parseIdentifier3.id;
-        var _await$apolloFetching2 = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("GET", setLoading), function () {
-            return client.query({
-              query: GET_RECORD,
-              variables: {
-                entryId: recordId
-              },
-              fetchPolicy: "network-only"
-            });
-          }),
-          response = _await$apolloFetching2.data;
+        const {
+          id: recordId
+        } = parseIdentifier(id);
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("GET", setLoading), () => client.query({
+          query: GET_RECORD,
+          variables: {
+            entryId: recordId
+          },
+          fetchPolicy: "network-only"
+        }));
         if (!response) {
-          throw new Error("Could not fetch record \"".concat(recordId, "\" - no response."));
+          throw new Error(`Could not fetch record "${recordId}" - no response.`);
         }
-        var _getResponseData2 = getResponseData(response, mode),
-          data = _getResponseData2.data,
-          error = _getResponseData2.error;
+        const {
+          data,
+          error
+        } = getResponseData(response);
         if (error && error.code !== "NOT_FOUND") {
           throw new Error("Network error while syncing record");
         }
         if (!data) {
           // No record found - must be deleted by previous operation
-          setRecords(function (prev) {
-            return prev.filter(function (record) {
-              return record.id !== recordId;
-            });
+          setRecords(prev => {
+            return prev.filter(record => record.id !== recordId);
           });
+          setMeta(meta => ({
+            ...meta,
+            totalCount: --meta.totalCount
+          }));
           return data;
         }
-        setRecords(function (prev) {
-          var index = prev.findIndex(function (record) {
-            return record.id === recordId;
-          });
+        setRecords(prev => {
+          const index = prev.findIndex(record => record.id === recordId);
 
           // No record found in the list - must be added by previous operation
           if (index === -1) {
-            return [data].concat((0, _toConsumableArray2.default)(prev));
+            return [data, ...prev];
           }
-          var next = (0, _toConsumableArray2.default)(prev);
+          const next = [...prev];
           next[index] = data;
           return next;
         });
-        setTags(function (tags) {
+        setMeta(meta => ({
+          ...meta,
+          totalCount: ++meta.totalCount
+        }));
+        setTags(tags => {
           if (!data.tags || data.tags.length === 0) {
             return tags;
           }
@@ -244,37 +243,36 @@ var SearchRecordsProvider = exports.SearchRecordsProvider = function SearchRecor
         });
         return data;
       },
-      createRecord: async function createRecord(record) {
+      async createRecord(record) {
         if (!CREATE_RECORD) {
           throw new Error("Missing CREATE_RECORD operation.");
         }
-        var _await$apolloFetching3 = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("CREATE", setLoading), function () {
-            return client.mutate({
-              mutation: CREATE_RECORD,
-              variables: {
-                data: record
-              }
-            });
-          }),
-          response = _await$apolloFetching3.data;
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("CREATE", setLoading), () => client.mutate({
+          mutation: CREATE_RECORD,
+          variables: {
+            data: record
+          }
+        }));
         if (!response) {
           throw new Error("Network error while creating search record.");
         }
-        var _getResponseData3 = getResponseData(response, mode),
-          data = _getResponseData3.data,
-          error = _getResponseData3.error;
+        const {
+          data,
+          error
+        } = getResponseData(response);
         if (!data) {
           throw new Error(error?.message || "Could not create record");
         }
-        setRecords(function (prev) {
-          return [].concat((0, _toConsumableArray2.default)(prev), [data]);
+        setRecords(prev => {
+          return [...prev, data];
         });
-        setMeta(function (meta) {
-          return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, meta), {}, {
-            totalCount: ++meta.totalCount
-          });
-        });
-        setTags(function (tags) {
+        setMeta(meta => ({
+          ...meta,
+          totalCount: ++meta.totalCount
+        }));
+        setTags(tags => {
           if (!data.tags || data.tags.length === 0) {
             return tags;
           }
@@ -282,54 +280,54 @@ var SearchRecordsProvider = exports.SearchRecordsProvider = function SearchRecor
         });
         return data;
       },
-      updateRecord: async function updateRecord(record, contextFolderId) {
+      async updateRecord(record, contextFolderId) {
         if (!contextFolderId) {
           throw new Error("`folderId` is mandatory");
         }
         if (!UPDATE_RECORD) {
           throw new Error("Missing UPDATE_RECORD operation.");
         }
-        var id = record.id,
-          location = record.location,
-          data = record.data,
-          title = record.title,
-          content = record.content;
-        var _await$apolloFetching4 = await (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
-                }
-              }
-            });
-          }),
-          response = _await$apolloFetching4.data;
+        const {
+          id,
+          location,
+          data,
+          title,
+          content
+        } = record;
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("UPDATE", setLoading), () => client.mutate({
+          mutation: UPDATE_RECORD,
+          variables: {
+            id,
+            data: {
+              title,
+              content,
+              location,
+              data
+            }
+          }
+        }));
         if (!response) {
           throw new Error("Network error while updating record");
         }
-        var _getResponseData4 = getResponseData(response, mode),
-          result = _getResponseData4.data,
-          error = _getResponseData4.error;
+        const {
+          data: result,
+          error
+        } = getResponseData(response);
         if (!result) {
           throw new Error(error?.message || "Could not update record");
         }
-        setRecords(function (records) {
-          var index = records.findIndex(function (record) {
-            return record.id === id;
-          });
+        setRecords(records => {
+          const index = records.findIndex(record => record.id === id);
           if (index === -1) {
-            return [result].concat((0, _toConsumableArray2.default)(records));
+            return [result, ...records];
           }
-          var next = (0, _toConsumableArray2.default)(records);
+          const next = [...records];
           next[index] = result;
           return next;
         });
-        setTags(function (tags) {
+        setTags(tags => {
           if (!data.tags || data.tags.length === 0) {
             return tags;
           }
@@ -337,94 +335,94 @@ var SearchRecordsProvider = exports.SearchRecordsProvider = function SearchRecor
         });
         return result;
       },
-      moveRecord: async function moveRecord(record) {
-        var id = record.id,
-          location = record.location;
-        var folderId = location.folderId;
-        var _await$apolloFetching5 = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("MOVE", setLoading), function () {
-            return client.mutate({
-              mutation: MOVE_RECORD,
-              variables: {
-                id: id,
-                folderId: folderId
-              }
-            });
-          }),
-          response = _await$apolloFetching5.data;
+      moveRecord: async record => {
+        const {
+          id,
+          location
+        } = record;
+        const {
+          folderId
+        } = location;
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("MOVE", setLoading), () => client.mutate({
+          mutation: MOVE_RECORD,
+          variables: {
+            id,
+            folderId
+          }
+        }));
         if (!response) {
           throw new Error("Network error while moving record.");
         }
-        var _getResponseData5 = getResponseData(response, mode),
-          data = _getResponseData5.data,
-          error = _getResponseData5.error;
+        const {
+          data,
+          error
+        } = getResponseData(response);
         if (!data) {
           throw new Error(error?.message || "Could not move record.");
         }
-        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
-          });
+        setRecords(prev => {
+          return prev.filter(record => record.id !== id);
         });
+        setMeta(meta => ({
+          ...meta,
+          totalCount: --meta.totalCount
+        }));
       },
-      deleteRecord: async function deleteRecord(record) {
+      async deleteRecord(record) {
         if (!DELETE_RECORD) {
           throw new Error("Missing DELETE_RECORD operation.");
         }
-        var id = record.id;
-        var _await$apolloFetching6 = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("DELETE", setLoading), function () {
-            return client.mutate({
-              mutation: DELETE_RECORD,
-              variables: {
-                id: id
-              }
-            });
-          }),
-          response = _await$apolloFetching6.data;
+        const {
+          id
+        } = record;
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("DELETE", setLoading), () => client.mutate({
+          mutation: DELETE_RECORD,
+          variables: {
+            id
+          }
+        }));
         if (!response) {
           throw new Error("Network error while deleting record.");
         }
-        var _getResponseData6 = getResponseData(response, mode),
-          data = _getResponseData6.data,
-          error = _getResponseData6.error;
+        const {
+          data,
+          error
+        } = getResponseData(response);
         if (!data) {
           throw new Error(error?.message || "Could not delete record");
         }
-        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
-          });
+        setRecords(prev => {
+          return prev.filter(record => record.id !== id);
         });
+        setMeta(meta => ({
+          ...meta,
+          totalCount: --meta.totalCount
+        }));
         return true;
       },
-      listTags: async function listTags(params) {
+      async listTags(params) {
         if (!LIST_TAGS) {
           throw new Error("Missing LIST_TAGS operation.");
         }
-        var _await$apolloFetching7 = await (0, _handlers.apolloFetchingHandler)((0, _handlers.loadingHandler)("LIST", setLoading), function () {
-            return client.query({
-              query: LIST_TAGS,
-              variables: {
-                where: params.where
-              }
-            });
-          }),
-          response = _await$apolloFetching7.data;
+        const {
+          data: response
+        } = await apolloFetchingHandler(loadingHandler("LIST", setLoading), () => client.query({
+          query: LIST_TAGS,
+          variables: {
+            where: params.where
+          }
+        }));
         if (!response) {
           throw new Error("Network error while fetching tags.");
         }
-        var _getResponseData7 = getResponseData(response, mode),
-          data = _getResponseData7.data,
-          error = _getResponseData7.error;
+        const {
+          data,
+          error
+        } = getResponseData(response);
         if (!data) {
           throw new Error(error?.message || "Could not fetch tags");
         }
@@ -433,7 +431,7 @@ var SearchRecordsProvider = exports.SearchRecordsProvider = function SearchRecor
       }
     };
   }, [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, {
+  return /*#__PURE__*/React.createElement(SearchRecordsContext.Provider, {
     value: context
   }, children);
 };