@webiny/app-aco 6.3.0-beta.4 → 6.4.0-beta.0

package/contexts/records.js

@@ -1,439 +1,316 @@
-import React, { useMemo } from "react";
+import react, { useMemo } from "react";
 import sortBy from "lodash/sortBy.js";
 import unionBy from "lodash/unionBy.js";
-import lodashMerge from "lodash/merge.js";
+import merge 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 SearchRecordsContext = /*#__PURE__*/ react.createContext(void 0);
 const defaultLoading = {
-  INIT: true,
-  LIST: false,
-  LIST_MORE: false,
-  GET: false,
-  MOVE: false,
-  CREATE: false,
-  UPDATE: false,
-  DELETE: false
+    INIT: true,
+    LIST: false,
+    LIST_MORE: false,
+    GET: false,
+    MOVE: false,
+    CREATE: false,
+    UPDATE: false,
+    DELETE: false
 };
-const mergeAndSortTags = (oldTagItems, newTags) => {
-  if (!newTags.length) {
-    return oldTagItems;
-  }
-  const newTagItems = newTags.map(tag => ({
-    tag
-  })); // create TagItem[] from array of strings
-  const mergedTagItems = unionBy(oldTagItems, newTagItems, "tag"); // merge the two arrays
-
-  return sortBy(mergedTagItems, ["tag"]);
-};
-const getResponseData = response => {
-  return response?.content || {};
+const mergeAndSortTags = (oldTagItems, newTags)=>{
+    if (!newTags.length) return oldTagItems;
+    const newTagItems = newTags.map((tag)=>({
+            tag
+        }));
+    const mergedTagItems = unionBy(oldTagItems, newTagItems, "tag");
+    return sortBy(mergedTagItems, [
+        "tag"
+    ]);
 };
+const getResponseData = (response)=>response?.content || {};
 const defaultMeta = {
-  totalCount: 0,
-  hasMoreItems: false,
-  cursor: null
+    totalCount: 0,
+    hasMoreItems: false,
+    cursor: null
 };
-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,
-      tags,
-      loading,
-      meta,
-      addRecordToCache: record => {
-        setRecords(prev => {
-          return [record, ...prev];
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: ++meta.totalCount
-        }));
-      },
-      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) {
-            const next = [...prev];
-            next[index] = lodashMerge({}, prev[index], record);
-            return next;
-          }
-          return [record, ...prev];
-        });
-      },
-      removeRecordFromCache: id => {
-        setRecords(prev => {
-          return prev.filter(record => record.id !== id && !record.id.startsWith(`${id}#`));
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: --meta.totalCount
-        }));
-      },
-      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.
-         */
-        const totalCount = meta?.totalCount || 0;
-        if (after && records.length === totalCount) {
-          return records;
-        }
-        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.");
-        }
-        const {
-          data,
-          meta: responseMeta,
-          error
-        } = getResponseData(response);
-        if (!data || !responseMeta) {
-          throw new Error(error?.message || "Could not fetch records.");
-        }
-        setRecords(prev => {
-          // If there's no cursor, it means we're receiving a new list of records from scratch.
-          if (!after) {
-            return data;
-          }
-          return [...prev, ...data];
-        });
-        setMeta(() => responseMeta);
-        setLoading(prev => {
-          return {
-            ...prev,
-            INIT: false
-          };
-        });
-        return data;
-      },
-      async getRecord(id) {
-        if (!id) {
-          throw new Error("Record `id` is mandatory");
-        }
-        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 "${recordId}" - no response.`);
-        }
-        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(prev => {
-            return prev.filter(record => record.id !== recordId);
-          });
-          setMeta(meta => ({
-            ...meta,
-            totalCount: --meta.totalCount
-          }));
-          return data;
-        }
-        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, ...prev];
-          }
-          const next = [...prev];
-          next[index] = data;
-          return next;
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: ++meta.totalCount
-        }));
-        setTags(tags => {
-          if (!data.tags || data.tags.length === 0) {
-            return tags;
-          }
-          return mergeAndSortTags(tags, data.tags);
-        });
-        return data;
-      },
-      async createRecord(record) {
-        if (!CREATE_RECORD) {
-          throw new Error("Missing CREATE_RECORD operation.");
-        }
-        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.");
-        }
-        const {
-          data,
-          error
-        } = getResponseData(response);
-        if (!data) {
-          throw new Error(error?.message || "Could not create record");
-        }
-        setRecords(prev => {
-          return [...prev, data];
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: ++meta.totalCount
-        }));
-        setTags(tags => {
-          if (!data.tags || data.tags.length === 0) {
-            return tags;
-          }
-          return mergeAndSortTags(tags, data.tags);
-        });
-        return data;
-      },
-      async updateRecord(record, contextFolderId) {
-        if (!contextFolderId) {
-          throw new Error("`folderId` is mandatory");
-        }
-        if (!UPDATE_RECORD) {
-          throw new Error("Missing UPDATE_RECORD operation.");
-        }
-        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
+const SearchRecordsProvider = ({ columns, children })=>{
+    const { app, client } = useAcoApp();
+    const { model } = app;
+    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(()=>({
+            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(()=>({
+            records,
+            tags,
+            loading,
+            meta,
+            addRecordToCache: (record)=>{
+                setRecords((prev)=>[
+                        record,
+                        ...prev
+                    ]);
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: ++meta.totalCount
+                    }));
+            },
+            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) {
+                        const next = [
+                            ...prev
+                        ];
+                        next[index] = merge({}, prev[index], record);
+                        return next;
+                    }
+                    return [
+                        record,
+                        ...prev
+                    ];
+                });
+            },
+            removeRecordFromCache: (id)=>{
+                setRecords((prev)=>prev.filter((record)=>record.id !== id && !record.id.startsWith(`${id}#`)));
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: --meta.totalCount
+                    }));
+            },
+            async listRecords (params) {
+                const { after, limit, sort: sorting, search, where } = params;
+                const totalCount = meta?.totalCount || 0;
+                if (after && records.length === totalCount) return records;
+                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.");
+                const { data, meta: responseMeta, error } = getResponseData(response);
+                if (!data || !responseMeta) throw new Error(error?.message || "Could not fetch records.");
+                setRecords((prev)=>{
+                    if (!after) return data;
+                    return [
+                        ...prev,
+                        ...data
+                    ];
+                });
+                setMeta(()=>responseMeta);
+                setLoading((prev)=>({
+                        ...prev,
+                        INIT: false
+                    }));
+                return data;
+            },
+            async getRecord (id) {
+                if (!id) throw new Error("Record `id` is mandatory");
+                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 "${recordId}" - no response.`);
+                const { data, error } = getResponseData(response);
+                if (error && "NOT_FOUND" !== error.code) throw new Error("Network error while syncing record");
+                if (!data) {
+                    setRecords((prev)=>prev.filter((record)=>record.id !== recordId));
+                    setMeta((meta)=>({
+                            ...meta,
+                            totalCount: --meta.totalCount
+                        }));
+                    return data;
+                }
+                setRecords((prev)=>{
+                    const index = prev.findIndex((record)=>record.id === recordId);
+                    if (-1 === index) return [
+                        data,
+                        ...prev
+                    ];
+                    const next = [
+                        ...prev
+                    ];
+                    next[index] = data;
+                    return next;
+                });
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: ++meta.totalCount
+                    }));
+                setTags((tags)=>{
+                    if (!data.tags || 0 === data.tags.length) return tags;
+                    return mergeAndSortTags(tags, data.tags);
+                });
+                return data;
+            },
+            async createRecord (record) {
+                if (!CREATE_RECORD) throw new Error("Missing CREATE_RECORD operation.");
+                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.");
+                const { data, error } = getResponseData(response);
+                if (!data) throw new Error(error?.message || "Could not create record");
+                setRecords((prev)=>[
+                        ...prev,
+                        data
+                    ]);
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: ++meta.totalCount
+                    }));
+                setTags((tags)=>{
+                    if (!data.tags || 0 === data.tags.length) return tags;
+                    return mergeAndSortTags(tags, data.tags);
+                });
+                return data;
+            },
+            async updateRecord (record, contextFolderId) {
+                if (!contextFolderId) throw new Error("`folderId` is mandatory");
+                if (!UPDATE_RECORD) throw new Error("Missing UPDATE_RECORD operation.");
+                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");
+                const { data: result, error } = getResponseData(response);
+                if (!result) throw new Error(error?.message || "Could not update record");
+                setRecords((records)=>{
+                    const index = records.findIndex((record)=>record.id === id);
+                    if (-1 === index) return [
+                        result,
+                        ...records
+                    ];
+                    const next = [
+                        ...records
+                    ];
+                    next[index] = result;
+                    return next;
+                });
+                setTags((tags)=>{
+                    if (!data.tags || 0 === data.tags.length) return tags;
+                    return mergeAndSortTags(tags, data.tags);
+                });
+                return result;
+            },
+            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.");
+                const { data, error } = getResponseData(response);
+                if (!data) throw new Error(error?.message || "Could not move record.");
+                setRecords((prev)=>prev.filter((record)=>record.id !== id));
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: --meta.totalCount
+                    }));
+            },
+            async deleteRecord (record) {
+                if (!DELETE_RECORD) throw new Error("Missing DELETE_RECORD operation.");
+                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.");
+                const { data, error } = getResponseData(response);
+                if (!data) throw new Error(error?.message || "Could not delete record");
+                setRecords((prev)=>prev.filter((record)=>record.id !== id));
+                setMeta((meta)=>({
+                        ...meta,
+                        totalCount: --meta.totalCount
+                    }));
+                return true;
+            },
+            async listTags (params) {
+                if (!LIST_TAGS) throw new Error("Missing LIST_TAGS operation.");
+                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.");
+                const { data, error } = getResponseData(response);
+                if (!data) throw new Error(error?.message || "Could not fetch tags");
+                setTags(data);
+                return data;
             }
-          }
-        }));
-        if (!response) {
-          throw new Error("Network error while updating record");
-        }
-        const {
-          data: result,
-          error
-        } = getResponseData(response);
-        if (!result) {
-          throw new Error(error?.message || "Could not update record");
-        }
-        setRecords(records => {
-          const index = records.findIndex(record => record.id === id);
-          if (index === -1) {
-            return [result, ...records];
-          }
-          const next = [...records];
-          next[index] = result;
-          return next;
-        });
-        setTags(tags => {
-          if (!data.tags || data.tags.length === 0) {
-            return tags;
-          }
-          return mergeAndSortTags(tags, data.tags);
-        });
-        return result;
-      },
-      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.");
-        }
-        const {
-          data,
-          error
-        } = getResponseData(response);
-        if (!data) {
-          throw new Error(error?.message || "Could not move record.");
-        }
-        setRecords(prev => {
-          return prev.filter(record => record.id !== id);
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: --meta.totalCount
-        }));
-      },
-      async deleteRecord(record) {
-        if (!DELETE_RECORD) {
-          throw new Error("Missing DELETE_RECORD operation.");
-        }
-        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.");
-        }
-        const {
-          data,
-          error
-        } = getResponseData(response);
-        if (!data) {
-          throw new Error(error?.message || "Could not delete record");
-        }
-        setRecords(prev => {
-          return prev.filter(record => record.id !== id);
-        });
-        setMeta(meta => ({
-          ...meta,
-          totalCount: --meta.totalCount
-        }));
-        return true;
-      },
-      async listTags(params) {
-        if (!LIST_TAGS) {
-          throw new Error("Missing LIST_TAGS operation.");
-        }
-        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.");
-        }
-        const {
-          data,
-          error
-        } = getResponseData(response);
-        if (!data) {
-          throw new Error(error?.message || "Could not fetch tags");
-        }
-        setTags(data);
-        return data;
-      }
-    };
-  }, [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.createElement(SearchRecordsContext.Provider, {
-    value: context
-  }, children);
+        }), [
+        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.createElement(SearchRecordsContext.Provider, {
+        value: context
+    }, children);
 };
+export { SearchRecordsContext, SearchRecordsProvider };
 
 //# sourceMappingURL=records.js.map