@webiny/api-website-builder 6.3.0 → 6.4.0-beta.1

package/graphql/pages/pages.gql.js

@@ -22,332 +22,229 @@ import { ListDeletedPagesUseCase } from "../../features/pages/ListDeletedPages/i
 import { TrashPageUseCase } from "../../features/pages/TrashPage/index.js";
 import { RestorePageUseCase } from "../../features/pages/RestorePage/index.js";
 import { GetPageLanguagePathsUseCase } from "../../features/pages/GetPageLanguagePaths/index.js";
-export const createPagesSchema = () => {
-  const pageGraphQL = new GraphQLSchemaPlugin({
-    typeDefs: pagesTypeDefs,
-    resolvers: {
-      WbQuery: {
-        getPageModel: async (_, __, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            return context.container.resolve(PageModel);
-          });
-        },
-        getPageByPath: async (_, {
-          path
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const getPageByPath = context.container.resolve(GetPageByPathUseCase);
-            const result = await getPageByPath.execute(path);
-            if (result.isFail()) {
-              throw new NotFoundError(`Page ${path} was not found!`);
+import { UpdatePageRevisionDescriptionUseCase } from "../../features/pages/UpdatePageRevisionDescription/index.js";
+const createPagesSchema = ()=>{
+    const pageGraphQL = new GraphQLSchemaPlugin({
+        typeDefs: pagesTypeDefs,
+        resolvers: {
+            WbQuery: {
+                getPageModel: async (_, __, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        return context.container.resolve(PageModel);
+                    }),
+                getPageByPath: async (_, { path }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const getPageByPath = context.container.resolve(GetPageByPathUseCase);
+                        const result = await getPageByPath.execute(path);
+                        if (result.isFail()) throw new NotFoundError(`Page ${path} was not found!`);
+                        const page = result.value;
+                        return {
+                            id: page.id,
+                            entryId: page.entryId,
+                            properties: page.properties,
+                            bindings: page.bindings,
+                            elements: page.elements
+                        };
+                    }),
+                getPageById: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const getPageById = context.container.resolve(GetPageByIdUseCase);
+                        const result = await getPageById.execute(id);
+                        if (result.isFail()) throw new NotFoundError(`Page with id "${id}" was not found!`);
+                        return result.value;
+                    }),
+                getPageRevisions: async (_, { entryId }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const getPageRevisions = context.container.resolve(GetPageRevisionsUseCase);
+                        const result = await getPageRevisions.execute(entryId);
+                        if (result.isFail()) throw new Error(result.error.message);
+                        const revisions = result.value;
+                        return revisions.map((page)=>({
+                                id: page.id,
+                                entryId: page.entryId,
+                                version: page.version,
+                                title: page.properties.title,
+                                status: page.status,
+                                locked: page.locked,
+                                savedOn: page.savedOn,
+                                createdOn: page.createdOn,
+                                createdBy: page.createdBy,
+                                revisionDescription: page.revisionDescription
+                            }));
+                    }),
+                listPages: async (_, args, context)=>{
+                    try {
+                        ensureAuthentication(context);
+                        const listPages = context.container.resolve(ListPagesUseCase);
+                        const result = await listPages.execute(args);
+                        if (result.isFail()) throw result.error;
+                        const { pages, meta } = result.value;
+                        return new ListResponse(pages, meta);
+                    } catch (e) {
+                        return new ErrorResponse(e);
+                    }
+                },
+                listDeletedPages: async (_, args, context)=>{
+                    try {
+                        ensureAuthentication(context);
+                        const listPages = context.container.resolve(ListDeletedPagesUseCase);
+                        const result = await listPages.execute(args);
+                        if (result.isFail()) throw result.error;
+                        const { pages, meta } = result.value;
+                        return new ListResponse(pages, meta);
+                    } catch (e) {
+                        return new ErrorResponse(e);
+                    }
+                },
+                getSettings: async (_, __, context)=>{
+                    ensureAuthentication(context);
+                    const keyValueStore = context.container.resolve(KeyValueStore);
+                    const result = await keyValueStore.get(WEBSITE_BUILDER_SETTINGS);
+                    if (result.isFail()) return new Response({
+                        previewDomain: "http://localhost:3000"
+                    });
+                    const settings = result.value;
+                    return new Response({
+                        previewDomain: settings.previewDomain ?? "http://localhost:3000"
+                    });
+                },
+                getIntegrations: async (_, __, context)=>{
+                    ensureAuthentication(context);
+                    const keyValueStore = context.container.resolve(KeyValueStore);
+                    const settings = await keyValueStore.get(WEBSITE_BUILDER_INTEGRATIONS);
+                    if (settings.isFail()) return new Response({});
+                    return new Response(settings.value);
+                }
+            },
+            WbMutation: {
+                createPage: async (_, { data }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const createPage = context.container.resolve(CreatePageUseCase);
+                        const result = await createPage.execute(data);
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                updatePage: async (_, { id, data }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const updatePage = context.container.resolve(UpdatePageUseCase);
+                        const result = await updatePage.execute(id, data);
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                updatePageRevisionDescription: async (_, { id, revisionDescription }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const updatePageRevisionDescription = context.container.resolve(UpdatePageRevisionDescriptionUseCase);
+                        const result = await updatePageRevisionDescription.execute(id, revisionDescription);
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                duplicatePage: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const duplicatePage = context.container.resolve(DuplicatePageUseCase);
+                        const result = await duplicatePage.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                translatePage: async (_, { pageId, languageCode, folderId }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const translatePage = context.container.resolve(TranslatePageUseCase);
+                        const result = await translatePage.execute({
+                            pageId,
+                            languageCode,
+                            folderId
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                publishPage: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const publishPage = context.container.resolve(PublishPageUseCase);
+                        const result = await publishPage.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                unpublishPage: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const unpublishPage = context.container.resolve(UnpublishPageUseCase);
+                        const result = await unpublishPage.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                movePage: async (_, { id, folderId }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const movePage = context.container.resolve(MovePageUseCase);
+                        const result = await movePage.execute({
+                            id,
+                            folderId
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return true;
+                    }),
+                createPageRevisionFrom: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const createRevision = context.container.resolve(CreatePageRevisionFromUseCase);
+                        const result = await createRevision.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                deletePage: async (_, { id, permanently }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const deletePage = context.container.resolve(permanently ? DeletePageUseCase : TrashPageUseCase);
+                        const result = await deletePage.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return true;
+                    }),
+                restorePage: async (_, { id }, context)=>resolve(async ()=>{
+                        ensureAuthentication(context);
+                        const restorePage = context.container.resolve(RestorePageUseCase);
+                        const result = await restorePage.execute({
+                            id
+                        });
+                        if (result.isFail()) throw new Error(result.error.message);
+                        return result.value;
+                    }),
+                updateSettings: async (_, args, context)=>resolve(async ()=>{
+                        ensureAuthentication(context, {
+                            permission: "wb.settings"
+                        });
+                        const keyValueStore = context.container.resolve(KeyValueStore);
+                        await keyValueStore.set(WEBSITE_BUILDER_SETTINGS, args.data);
+                        return true;
+                    }),
+                updateIntegrations: async (_, args, context)=>resolve(async ()=>{
+                        ensureAuthentication(context, {
+                            permission: "wb.settings"
+                        });
+                        const keyValueStore = context.container.resolve(KeyValueStore);
+                        await keyValueStore.set(WEBSITE_BUILDER_INTEGRATIONS, args.data);
+                        return true;
+                    })
+            },
+            WbPage: {
+                languagePaths: async (page, _, context)=>{
+                    const properties = page.properties ?? {};
+                    const rootEntryId = properties.sourcePage ?? page.entryId;
+                    if (!rootEntryId) return {};
+                    const getLanguagePaths = context.container.resolve(GetPageLanguagePathsUseCase);
+                    const result = await getLanguagePaths.execute(rootEntryId);
+                    return result.isFail() ? {} : result.value;
+                }
             }
-            const page = result.value;
-            return {
-              id: page.id,
-              entryId: page.entryId,
-              properties: page.properties,
-              bindings: page.bindings,
-              elements: page.elements
-            };
-          });
-        },
-        getPageById: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const getPageById = context.container.resolve(GetPageByIdUseCase);
-            const result = await getPageById.execute(id);
-            if (result.isFail()) {
-              throw new NotFoundError(`Page with id "${id}" was not found!`);
-            }
-            return result.value;
-          });
-        },
-        getPageRevisions: async (_, {
-          entryId
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const getPageRevisions = context.container.resolve(GetPageRevisionsUseCase);
-            const result = await getPageRevisions.execute(entryId);
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            const revisions = result.value;
-            return revisions.map(page => {
-              return {
-                id: page.id,
-                entryId: page.entryId,
-                version: page.version,
-                title: page.properties.title,
-                status: page.status,
-                locked: page.locked,
-                savedOn: page.savedOn
-              };
-            });
-          });
-        },
-        listPages: async (_, args, context) => {
-          try {
-            ensureAuthentication(context);
-            const listPages = context.container.resolve(ListPagesUseCase);
-            const result = await listPages.execute(args);
-            if (result.isFail()) {
-              throw result.error;
-            }
-            const {
-              pages,
-              meta
-            } = result.value;
-            return new ListResponse(pages, meta);
-          } catch (e) {
-            return new ErrorResponse(e);
-          }
-        },
-        listDeletedPages: async (_, args, context) => {
-          try {
-            ensureAuthentication(context);
-            const listPages = context.container.resolve(ListDeletedPagesUseCase);
-            const result = await listPages.execute(args);
-            if (result.isFail()) {
-              throw result.error;
-            }
-            const {
-              pages,
-              meta
-            } = result.value;
-            return new ListResponse(pages, meta);
-          } catch (e) {
-            return new ErrorResponse(e);
-          }
-        },
-        getSettings: async (_, __, context) => {
-          ensureAuthentication(context);
-          const keyValueStore = context.container.resolve(KeyValueStore);
-          const result = await keyValueStore.get(WEBSITE_BUILDER_SETTINGS);
-          if (result.isFail()) {
-            return new Response({
-              // TODO: add a WB GetSettings use case and a Settings domain model with defaults.
-              previewDomain: "http://localhost:3000"
-            });
-          }
-          const settings = result.value;
-          return new Response({
-            // TODO: add a WB GetSettings use case and a Settings domain model with defaults.
-            previewDomain: settings.previewDomain ?? "http://localhost:3000"
-          });
-        },
-        getIntegrations: async (_, __, context) => {
-          ensureAuthentication(context);
-          const keyValueStore = context.container.resolve(KeyValueStore);
-          const settings = await keyValueStore.get(WEBSITE_BUILDER_INTEGRATIONS);
-          if (settings.isFail()) {
-            return new Response({});
-          }
-          return new Response(settings.value);
-        }
-      },
-      WbMutation: {
-        createPage: async (_, {
-          data
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const createPage = context.container.resolve(CreatePageUseCase);
-            const result = await createPage.execute(data);
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        updatePage: async (_, {
-          id,
-          data
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const updatePage = context.container.resolve(UpdatePageUseCase);
-            const result = await updatePage.execute(id, data);
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        duplicatePage: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const duplicatePage = context.container.resolve(DuplicatePageUseCase);
-            const result = await duplicatePage.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        translatePage: async (_, {
-          pageId,
-          languageCode,
-          folderId
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const translatePage = context.container.resolve(TranslatePageUseCase);
-            const result = await translatePage.execute({
-              pageId,
-              languageCode,
-              folderId
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        publishPage: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const publishPage = context.container.resolve(PublishPageUseCase);
-            const result = await publishPage.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        unpublishPage: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const unpublishPage = context.container.resolve(UnpublishPageUseCase);
-            const result = await unpublishPage.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        movePage: async (_, {
-          id,
-          folderId
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const movePage = context.container.resolve(MovePageUseCase);
-            const result = await movePage.execute({
-              id,
-              folderId
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return true;
-          });
-        },
-        createPageRevisionFrom: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const createRevision = context.container.resolve(CreatePageRevisionFromUseCase);
-            const result = await createRevision.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        deletePage: async (_, {
-          id,
-          permanently
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const deletePage = context.container.resolve(
-            /**
-             * If "permanent" flag is set, we want to permanently delete the page. Otherwise, we just want to trash it.
-             * This allows us to have a two-step deletion process, where pages are first moved to trash and can be restored from there, before being permanently deleted.
-             */
-            permanently ? DeletePageUseCase : TrashPageUseCase);
-            const result = await deletePage.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return true;
-          });
-        },
-        restorePage: async (_, {
-          id
-        }, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context);
-            const restorePage = context.container.resolve(RestorePageUseCase);
-            const result = await restorePage.execute({
-              id
-            });
-            if (result.isFail()) {
-              throw new Error(result.error.message);
-            }
-            return result.value;
-          });
-        },
-        // TODO: move these settings updates into dedicated use cases
-        updateSettings: async (_, args, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context, {
-              permission: "wb.settings"
-            });
-            const keyValueStore = context.container.resolve(KeyValueStore);
-            await keyValueStore.set(WEBSITE_BUILDER_SETTINGS, args.data);
-            return true;
-          });
-        },
-        updateIntegrations: async (_, args, context) => {
-          return resolve(async () => {
-            ensureAuthentication(context, {
-              permission: "wb.settings"
-            });
-            const keyValueStore = context.container.resolve(KeyValueStore);
-            await keyValueStore.set(WEBSITE_BUILDER_INTEGRATIONS, args.data);
-            return true;
-          });
-        }
-      },
-      WbPage: {
-        languagePaths: async (page, _, context) => {
-          const properties = page.properties ?? {};
-          const rootEntryId = properties.sourcePage ?? page.entryId;
-          if (!rootEntryId) {
-            return {};
-          }
-          const getLanguagePaths = context.container.resolve(GetPageLanguagePathsUseCase);
-          const result = await getLanguagePaths.execute(rootEntryId);
-          return result.isFail() ? {} : result.value;
         }
-      }
-    }
-  });
-  pageGraphQL.name = "wb.graphql.pages";
-  return pageGraphQL;
+    });
+    pageGraphQL.name = "wb.graphql.pages";
+    return pageGraphQL;
 };
+export { createPagesSchema };
 
 //# sourceMappingURL=pages.gql.js.map