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

package/admin/contexts/Cms/index.js

@@ -1,504 +1,389 @@
-import React, { useMemo } from "react";
-import { config as appConfig } from "@webiny/app/config.js";
+import react, { useMemo } from "react";
+import { config } from "@webiny/app/config.js";
 import { useFeature } from "@webiny/app";
 import { EventPublisherFeature } from "@webiny/app/features/eventPublisher/index.js";
 import { EntryAfterCreateEvent } from "../../../features/contentEntry/events/EntryAfterCreateEvent.js";
 import { EntryAfterUpdateEvent } from "../../../features/contentEntry/events/EntryAfterUpdateEvent.js";
 import { EntryAfterDeleteEvent } from "../../../features/contentEntry/events/EntryAfterDeleteEvent.js";
-import { createBulkActionMutation, createCreateFromMutation, createCreateMutation, createDeleteMutation, createPublishMutation, createReadQuery, createReadSingletonQuery, createRevisionsQuery, createUnpublishMutation, createUpdateMutation, createUpdateSingletonMutation } from "@webiny/app-headless-cms-common";
+import { createBulkActionMutation, createCreateFromMutation, createCreateMutation, createDeleteMutation, createPublishMutation, createReadQuery, createReadSingletonQuery, createRevisionsQuery, createUnpublishMutation, createUpdateMutation, createUpdateRevisionDescriptionMutation, createUpdateSingletonMutation } from "@webiny/app-headless-cms-common";
 import { getFetchPolicy } from "../../../utils/getFetchPolicy.js";
 const defaultErrorMessage = "The system wasn't able to save the current entry. Please contact your support team to help you resolve this issue.";
-const catchErrorOnExecute = async (cb, options) => {
-  try {
-    return await cb();
-  } catch (ex) {
-    return {
-      data: {
-        content: {
-          data: null,
-          error: {
-            message: options?.message || defaultErrorMessage,
-            code: ex.code,
-            stack: ex.stack,
+const catchErrorOnExecute = async (cb, options)=>{
+    try {
+        return await cb();
+    } catch (ex) {
+        return {
             data: {
-              ...ex.data
+                content: {
+                    data: null,
+                    error: {
+                        message: options?.message || defaultErrorMessage,
+                        code: ex.code,
+                        stack: ex.stack,
+                        data: {
+                            ...ex.data
+                        }
+                    }
+                }
             }
-          }
-        }
-      }
-    };
-  }
+        };
+    }
 };
-export const CmsContext = /*#__PURE__*/React.createContext(undefined);
-export const CmsProvider = props => {
-  const apiUrl = appConfig.getKey("API_URL", process.env.REACT_APP_API_URL);
-  const apolloClient = useMemo(() => {
-    return props.createApolloClient({
-      uri: `${apiUrl}/cms/manage`
-    });
-  }, []);
-  const {
-    eventPublisher
-  } = useFeature(EventPublisherFeature);
-  const value = {
-    createApolloClient: props.createApolloClient,
-    apolloClient,
-    getEntry: async ({
-      model,
-      id
-    }) => {
-      const query = createReadQuery(model);
-      const isRevisionId = id.includes("#");
-      const response = await value.apolloClient.query({
-        query,
-        variables: isRevisionId ? {
-          revision: id
-        } : {
-          entryId: id
+const CmsContext = /*#__PURE__*/ react.createContext(void 0);
+const CmsProvider = (props)=>{
+    const apiUrl = config.getKey("API_URL", process.env.REACT_APP_API_URL);
+    const apolloClient = useMemo(()=>props.createApolloClient({
+            uri: `${apiUrl}/cms/manage`
+        }), []);
+    const { eventPublisher } = useFeature(EventPublisherFeature);
+    const value = {
+        createApolloClient: props.createApolloClient,
+        apolloClient,
+        getEntry: async ({ model, id })=>{
+            const query = createReadQuery(model);
+            const isRevisionId = id.includes("#");
+            const response = await value.apolloClient.query({
+                query,
+                variables: isRevisionId ? {
+                    revision: id
+                } : {
+                    entryId: id
+                },
+                fetchPolicy: getFetchPolicy(model)
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on getEntry query.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
         },
-        fetchPolicy: getFetchPolicy(model)
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on getEntry query.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    listEntryRevisions: async ({
-      model,
-      id
-    }) => {
-      const query = createRevisionsQuery(model);
-      const response = await value.apolloClient.query({
-        query,
-        variables: {
-          id
+        listEntryRevisions: async ({ model, id })=>{
+            const query = createRevisionsQuery(model);
+            const response = await value.apolloClient.query({
+                query,
+                variables: {
+                    id
+                },
+                fetchPolicy: "network-only"
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on getRevisions query.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.revisions;
+            if (error) return {
+                error
+            };
+            return {
+                revisions: data
+            };
         },
-        fetchPolicy: "network-only"
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on getRevisions query.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.revisions;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        revisions: data
-      };
-    },
-    getSingletonEntry: async ({
-      model
-    }) => {
-      const query = createReadSingletonQuery(model);
-      const response = await value.apolloClient.query({
-        query,
-        fetchPolicy: getFetchPolicy(model)
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on getSingletonEntry query.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    createEntry: async ({
-      model,
-      entry,
-      options
-    }) => {
-      const mutation = createCreateMutation(model);
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            data: entry,
-            options
-          },
-          fetchPolicy: getFetchPolicy(model)
-        });
-      }, {
-        message: "The system wasn't able to create a new entry. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on Create Entry mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      const createdEntry = data;
-      await eventPublisher.publish(new EntryAfterCreateEvent({
-        entry: createdEntry,
-        model
-      })).catch(e => {
-        console.error("[CmsProvider] Failed to publish EntryAfterCreateEvent", e);
-      });
-      return {
-        entry: createdEntry
-      };
-    },
-    createEntryRevisionFrom: async ({
-      model,
-      id,
-      input,
-      options
-    }) => {
-      const mutation = createCreateFromMutation(model);
-      const response = await catchErrorOnExecute(async () => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            revision: id,
-            data: input,
-            options
-          },
-          fetchPolicy: getFetchPolicy(model)
-        });
-      }, {
-        message: "The system wasn't able to create a new revision of the entry. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on Create Entry mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    updateEntryRevision: async ({
-      model,
-      entry,
-      options
-    }) => {
-      const mutation = createUpdateMutation(model);
-      const {
-        id,
-        ...input
-      } = entry;
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            revision: id,
-            data: input,
-            options
-          },
-          fetchPolicy: getFetchPolicy(model)
-        });
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on Update Entry mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      const updatedEntry = data;
-      await eventPublisher.publish(new EntryAfterUpdateEvent({
-        entry: updatedEntry,
-        model
-      })).catch(e => {
-        console.error("[CmsProvider] Failed to publish EntryAfterUpdateEvent", e);
-      });
-      return {
-        entry: updatedEntry
-      };
-    },
-    updateSingletonEntry: async ({
-      model,
-      entry,
-      options
-    }) => {
-      const mutation = createUpdateSingletonMutation(model);
-      // oxlint-disable-next-line typescript/no-unused-vars
-      const {
-        id,
-        ...input
-      } = entry;
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            data: input,
-            options
-          },
-          fetchPolicy: getFetchPolicy(model)
-        });
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on updateSingletonEntry mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    publishEntryRevision: async ({
-      model,
-      id
-    }) => {
-      const mutation = createPublishMutation(model);
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            revision: id
-          }
-        });
-      }, {
-        message: "The system wasn't able to publish the current entry. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        const error = {
-          message: "Missing response data on Publish Entry mutation.",
-          code: "MISSING_RESPONSE_DATA",
-          data: {}
-        };
-        return {
-          error
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    unpublishEntryRevision: async ({
-      model,
-      id
-    }) => {
-      const mutation = createUnpublishMutation(model);
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            revision: id
-          }
-        });
-      }, {
-        message: "The system wasn't able to unpublish the current entry. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on Unpublish Entry mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      return {
-        entry: data
-      };
-    },
-    deleteEntry: async ({
-      model,
-      id
-    }) => {
-      const mutation = createDeleteMutation(model);
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            revision: id,
-            permanently: false
-          }
-        });
-      }, {
-        message: "The system wasn't able to delete the current entry. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        const error = {
-          message: "Missing response data on Delete Entry mutation.",
-          code: "MISSING_RESPONSE_DATA",
-          data: {}
-        };
-        return {
-          error
-        };
-      }
-      const {
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      const entryId = id.split("#")[0];
-      await eventPublisher.publish(new EntryAfterDeleteEvent({
-        model,
-        id,
-        entryId
-      })).catch(e => {
-        console.error("[CmsProvider] Failed to publish EntryAfterDeleteEvent", e);
-      });
-      return true;
-    },
-    bulkAction: async ({
-      model,
-      action,
-      where,
-      search,
-      data
-    }) => {
-      const mutation = createBulkActionMutation(model);
-      const response = await catchErrorOnExecute(() => {
-        return value.apolloClient.mutate({
-          mutation,
-          variables: {
-            action,
-            where,
-            search,
-            data
-          }
-        });
-      }, {
-        message: "The system wasn't able to perform the bulk action. Please contact your support team to help you resolve this issue."
-      });
-      if (!response.data) {
-        return {
-          error: {
-            message: "Missing response data on Bulk Action mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      const {
-        data: responseData,
-        error
-      } = response.data.content;
-      if (error) {
-        return {
-          error
-        };
-      }
-      if (!responseData) {
-        return {
-          error: {
-            message: "Missing response data on Bulk Action mutation.",
-            code: "MISSING_RESPONSE_DATA",
-            data: {}
-          }
-        };
-      }
-      return responseData;
-    }
-  };
-  return /*#__PURE__*/React.createElement(CmsContext.Provider, Object.assign({
-    value: value
-  }, props));
+        getSingletonEntry: async ({ model })=>{
+            const query = createReadSingletonQuery(model);
+            const response = await value.apolloClient.query({
+                query,
+                fetchPolicy: getFetchPolicy(model)
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on getSingletonEntry query.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        createEntry: async ({ model, entry, options })=>{
+            const mutation = createCreateMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        data: entry,
+                        options
+                    },
+                    fetchPolicy: getFetchPolicy(model)
+                }), {
+                message: "The system wasn't able to create a new entry. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on Create Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            const createdEntry = data;
+            await eventPublisher.publish(new EntryAfterCreateEvent({
+                entry: createdEntry,
+                model
+            })).catch((e)=>{
+                console.error("[CmsProvider] Failed to publish EntryAfterCreateEvent", e);
+            });
+            return {
+                entry: createdEntry
+            };
+        },
+        createEntryRevisionFrom: async ({ model, id, input, options })=>{
+            const mutation = createCreateFromMutation(model);
+            const response = await catchErrorOnExecute(async ()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id,
+                        data: input,
+                        options
+                    },
+                    fetchPolicy: getFetchPolicy(model)
+                }), {
+                message: "The system wasn't able to create a new revision of the entry. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on Create Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        updateEntryRevision: async ({ model, entry, options })=>{
+            const mutation = createUpdateMutation(model);
+            const { id, ...input } = entry;
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id,
+                        data: input,
+                        options
+                    },
+                    fetchPolicy: getFetchPolicy(model)
+                }));
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on Update Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            const updatedEntry = data;
+            await eventPublisher.publish(new EntryAfterUpdateEvent({
+                entry: updatedEntry,
+                model
+            })).catch((e)=>{
+                console.error("[CmsProvider] Failed to publish EntryAfterUpdateEvent", e);
+            });
+            return {
+                entry: updatedEntry
+            };
+        },
+        updateSingletonEntry: async ({ model, entry, options })=>{
+            const mutation = createUpdateSingletonMutation(model);
+            const { id, ...input } = entry;
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        data: input,
+                        options
+                    },
+                    fetchPolicy: getFetchPolicy(model)
+                }));
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on updateSingletonEntry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        updateRevisionDescription: async ({ model, id, revisionDescription })=>{
+            const mutation = createUpdateRevisionDescriptionMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id,
+                        revisionDescription
+                    }
+                }));
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on updateRevisionDescription mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        publishEntryRevision: async ({ model, id })=>{
+            const mutation = createPublishMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id
+                    }
+                }), {
+                message: "The system wasn't able to publish the current entry. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) {
+                const error = {
+                    message: "Missing response data on Publish Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                };
+                return {
+                    error
+                };
+            }
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        unpublishEntryRevision: async ({ model, id })=>{
+            const mutation = createUnpublishMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id
+                    }
+                }), {
+                message: "The system wasn't able to unpublish the current entry. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on Unpublish Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            return {
+                entry: data
+            };
+        },
+        deleteEntry: async ({ model, id })=>{
+            const mutation = createDeleteMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        revision: id,
+                        permanently: false
+                    }
+                }), {
+                message: "The system wasn't able to delete the current entry. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) {
+                const error = {
+                    message: "Missing response data on Delete Entry mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                };
+                return {
+                    error
+                };
+            }
+            const { error } = response.data.content;
+            if (error) return {
+                error
+            };
+            const entryId = id.split("#")[0];
+            await eventPublisher.publish(new EntryAfterDeleteEvent({
+                model,
+                id,
+                entryId
+            })).catch((e)=>{
+                console.error("[CmsProvider] Failed to publish EntryAfterDeleteEvent", e);
+            });
+            return true;
+        },
+        bulkAction: async ({ model, action, where, search, data })=>{
+            const mutation = createBulkActionMutation(model);
+            const response = await catchErrorOnExecute(()=>value.apolloClient.mutate({
+                    mutation,
+                    variables: {
+                        action,
+                        where,
+                        search,
+                        data
+                    }
+                }), {
+                message: "The system wasn't able to perform the bulk action. Please contact your support team to help you resolve this issue."
+            });
+            if (!response.data) return {
+                error: {
+                    message: "Missing response data on Bulk Action mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            const { data: responseData, error } = response.data.content;
+            if (error) return {
+                error
+            };
+            if (!responseData) return {
+                error: {
+                    message: "Missing response data on Bulk Action mutation.",
+                    code: "MISSING_RESPONSE_DATA",
+                    data: {}
+                }
+            };
+            return responseData;
+        }
+    };
+    return /*#__PURE__*/ react.createElement(CmsContext.Provider, {
+        value: value,
+        ...props
+    });
 };
+export { CmsContext, CmsProvider };
 
 //# sourceMappingURL=index.js.map