@raketa-cloud/admin 0.0.6 → 0.0.8

package/src/cloud/documents/common.js

@@ -0,0 +1,84 @@
+import { gql } from "graphql-request";
+
+export function pageTypeFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+    }
+  `;
+}
+
+export function tagFragment() {
+  return gql`
+    {
+      id
+      name
+      slug
+    }
+  `;
+}
+
+export function paginationFragment() {
+  return gql`
+    {
+      currentPage
+      pagesCount
+      entriesCount
+      pageSize
+    }
+  `;
+}
+
+export function errorsFragment() {
+  return gql`
+    {
+      key
+      message
+      codes {
+        key
+        placeholders
+      }
+    }
+  `;
+}
+
+export function revisionMetaFragment() {
+  return gql`
+    {
+      id
+      title
+      description
+      operator
+      operatorMeta
+      locked
+      lockMessage
+    }
+  `;
+}
+
+export function revisionFragment() {
+  return gql`
+    {
+      id
+      title
+      slug
+      settings
+      widgets
+      visibility
+    }
+  `;
+}
+
+export function categoryFragment() {
+  return gql`
+    {
+      id
+      type
+      slug
+      name
+      settings
+    }
+  `;
+}

package/src/cloud/documents/pagesDocuments.js

@@ -0,0 +1,245 @@
+import { gql } from "graphql-request";
+import {
+  categoryFragment,
+  errorsFragment,
+  pageTypeFragment,
+  paginationFragment,
+  revisionMetaFragment,
+  tagFragment,
+} from "./common";
+
+function pageFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      originalId
+      translations
+      revisionsCount
+      tags ${tagFragment()}
+      pageType ${pageTypeFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+function pageRevisionFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      originalId
+      insertedAt
+      tags ${tagFragment()}
+      pageType ${pageTypeFragment()}
+      meta ${revisionMetaFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+const PageByIdDocument = gql`
+  query PageByID($input: IdInput!) {
+    page(input: $input) ${pageFragment()}
+  }
+`;
+
+const PageChangesDocument = gql`
+  query PageChanges($input: IdInput!) {
+    pageChanges(input: $input) {
+      list {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const PagesDocument = gql`
+  query Pages($input: PagesInput!) {
+    pages(input: $input) {
+      list ${pageFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const CreatePageDocument = gql`
+  mutation CreatePage($input: CreatePageInput!) {
+    createPage(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdatePageDocument = gql`
+  mutation UpdatePage($input: UpdatePageInput!) {
+    updatePage(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdatePageWidgetsDocument = gql`
+  mutation updatePageWidgets($input: UpdatePageWidgetsInput!) {
+    updatePageWidgets(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ClonePageDocument = gql`
+  mutation ClonePage($input: IdInput!) {
+    clonePage(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeletePageDocument = gql`
+  mutation DeletePage($input: PageDeleteInput!) {
+    deletePage(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const PageAndSiteDocument = gql`
+  query PageAndSite($input: SlugInput!) {
+    pageAndSite(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      originalId
+      translations
+      tags ${tagFragment()}
+      pageType ${pageTypeFragment()}
+      categories ${categoryFragment()}
+      websiteSettings
+    }
+  }
+`;
+
+const TranslatePageDocument = gql`
+  mutation TranslatePage($input: TranslatePageInput!) {
+    translatePage(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const PageRevisionsDocument = gql`
+  query PageRevisions($input: IdInput!) {
+    pageRevisions(input: $input) {
+      list ${pageRevisionFragment()}
+    }
+  }
+`;
+
+const PageRevisionDocument = gql`
+  query PageRevision($input: IdInput!) {
+    pageRevision(input: $input) ${pageRevisionFragment()}
+  }
+`;
+
+const StartPageRevisionDocument = gql`
+  mutation StartPageRevision($input: StartPageRevisionInput!) {
+    startPageRevision(input: $input) {
+      revision ${pageRevisionFragment()}
+      errors ${errorsFragment()}
+      pageErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const MergePageRevisionDocument = gql`
+  mutation MergePageRevision($input: MergePageRevisionInput!) {
+    mergePageRevision(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ChangePageSlugDocument = gql`
+  mutation ($input: ChangePageSlugInput!) {
+    changePageSlug(input: $input) {
+      page ${pageFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ReopenPageChangeDocument = gql`
+  mutation($input: ReopenPageChangeInput!)
+    {
+      reopenPageChange(input: $input) {
+        revision ${pageRevisionFragment()}
+        errors ${errorsFragment()}
+        pageErrors ${errorsFragment()}
+      }
+    }
+`;
+
+const LockPageRevisionDocument = gql`
+  mutation LockPageRevision($input: LockPageRevisionInput!) {
+    lockPageRevision(input: $input) {
+      revision ${pageRevisionFragment()}
+      errors ${errorsFragment()}
+      pageErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const UnlockPageRevisionDocument = gql`
+  mutation UnlockPageRevision($input: UnlockPageRevisionInput!) {
+    unlockPageRevision(input: $input) {
+      revision ${pageRevisionFragment()}
+      errors ${errorsFragment()}
+      pageErrors ${errorsFragment()}
+    }
+  }
+`;
+
+export {
+  PageByIdDocument,
+  PagesDocument,
+  CreatePageDocument,
+  UpdatePageDocument,
+  UpdatePageWidgetsDocument,
+  ClonePageDocument,
+  DeletePageDocument,
+  PageAndSiteDocument,
+  TranslatePageDocument,
+  PageRevisionDocument,
+  PageRevisionsDocument,
+  StartPageRevisionDocument,
+  MergePageRevisionDocument,
+  PageChangesDocument,
+  ChangePageSlugDocument,
+  ReopenPageChangeDocument,
+  LockPageRevisionDocument,
+  UnlockPageRevisionDocument,
+};

package/src/cloud/documents/redirectsDocuments.js

@@ -0,0 +1,82 @@
+import { gql } from "graphql-request";
+import { errorsFragment, paginationFragment } from "./common";
+
+function redirectFragment() {
+  return gql`
+    {
+      id
+      url
+      destination
+      httpResponseCode
+      note
+      updatedAt
+      createdAt
+    }
+  `;
+}
+
+const RedirectsDocument = gql`
+  query Redirects($input: RedirectsInput) {
+    redirects(input: $input) {
+      list ${redirectFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const RedirectByIdDocument = gql`
+  query RedirectByID($input: SimpleIdInput!) {
+    redirect(input: $input) ${redirectFragment()}
+  }
+`;
+
+const CreateRedirectDocument = gql`
+  mutation CreateRedirect($input: CreateRedirectInput!) {
+    createRedirect(input: $input) {
+      redirect ${redirectFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateRedirectDocument = gql`
+  mutation UpdateRedirect($input: UpdateRedirectInput!) {
+    updateRedirect(input: $input) {
+      redirect ${redirectFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeleteRedirectDocument = gql`
+  mutation DeleteRedirect($input: SimpleIdInput!) {
+    deleteRedirect(input: $input) {
+      redirect ${redirectFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const RedirectChangesDocument = gql`
+  query RedirectChanges($input: IdInput!) {
+    redirectChanges(input: $input) {
+      list {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        insertedAt
+      }
+    }
+  }
+`;
+
+export {
+  RedirectsDocument,
+  RedirectByIdDocument,
+  CreateRedirectDocument,
+  UpdateRedirectDocument,
+  DeleteRedirectDocument,
+  RedirectChangesDocument,
+};

package/src/cloud/documents/settingsDocuments.js

@@ -0,0 +1,23 @@
+import { gql } from "graphql-request";
+import { errorsFragment } from "./common";
+
+const SettingDocument = gql`
+  query Setting($locale: String!) {
+    setting(locale: $locale) {
+      value
+    }
+  }
+`;
+
+const UpdateSettingDocument = gql`
+  mutation updateSetting($input: UpdateSettingInput!) {
+    updateSetting(input: $input) {
+      setting {
+        value
+      }
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+export { SettingDocument, UpdateSettingDocument };

package/src/cloud/documents/tagsDocuments.js

@@ -0,0 +1,63 @@
+import { gql } from "graphql-request";
+import { errorsFragment, paginationFragment } from "./common";
+
+function tagFragment() {
+  return gql`
+    {
+      id
+      slug
+      name
+    }
+  `;
+}
+
+const TagsDocument = gql`
+  query Tags($input: TagsInput!) {
+    tags(input: $input) {
+      list ${tagFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const CreateTagDocument = gql`
+  mutation CreateTag($input: CreateTagInput!) {
+    createTag(input: $input) {
+      tag ${tagFragment()}
+      errors ${errorsFragment()}
+
+    }
+  }
+`;
+
+const UpdateTagDocument = gql`
+  mutation UpdateTag($input: UpdateTagInput!) {
+    updateTag(input: $input) {
+      tag ${tagFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeleteTagDocument = gql`
+  mutation DeleteTag($input: IdInput!) {
+    deleteTag(input: $input) {
+      tag ${tagFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const TagByIdDocument = gql`
+  query TagByID($input: IdInput!) {
+    tag(input: $input) ${tagFragment()}
+  }
+`;
+
+export {
+  TagsDocument,
+  CreateTagDocument,
+  UpdateTagDocument,
+  DeleteTagDocument,
+  TagByIdDocument,
+};

package/src/handlers/PageCloneHandler.js

@@ -0,0 +1,17 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const { errors } = await ctx.client.clonePage.clone(parent_id, ctx.locale);
+
+  if (errors) {
+    throw new Error(`Error cloning page: ${JSON.stringify(errors)}`);
+  }
+
+  return {
+    redirect: `/${ctx.locale}/pages`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/PageCloneHandler.test/create.test.js

@@ -0,0 +1,55 @@
+import ClonesPage from "../../cloud/ClonesPage";
+import PageCloneHandler from "../PageCloneHandler";
+
+import Factory from "../../../../../apps/admin/test/factory";
+import { testConfig } from "../../../../../apps/admin/test/handlersHelper";
+
+function buildCtx(page) {
+  return {
+    client: {
+      clonePage: new ClonesPage(testConfig, "token"),
+    },
+    params: { parent_id: page.id },
+    locale: "en",
+  };
+}
+
+describe("Clone page", () => {
+  test("clone successful", async () => {
+    const page = Factory.build("page");
+    const ctx = buildCtx(page);
+
+    const mockClone = jest
+      .spyOn(ctx.client.clonePage, "clone")
+      .mockImplementation(() => page);
+
+    const result = await PageCloneHandler.create(ctx);
+
+    expect(mockClone).toHaveBeenCalledWith(page.id, "en");
+
+    expect(result).toEqual({
+      redirect: "/en/pages",
+    });
+  });
+
+  test("clone failed", async () => {
+    const page = Factory.build("page");
+
+    const ctx = buildCtx(page);
+
+    const mockClone = jest
+      .spyOn(ctx.client.clonePage, "clone")
+      .mockImplementation(() => ({
+        page: null,
+        errors: [{ key: "generalError", message: "some error" }],
+      }));
+
+    expect(async () => {
+      await PageCloneHandler.create(ctx);
+    }).rejects.toThrow(
+      `Error cloning page: ${JSON.stringify([{ key: "generalError", message: "some error" }])}`
+    );
+
+    expect(mockClone).toHaveBeenCalledWith(page.id, "en");
+  });
+});

package/src/handlers/PageDeleteHandler.js

@@ -0,0 +1,68 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const page = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  if (!page) {
+    throw new Error(`Missing page #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      deleteAction: {
+        id: page.id,
+        redirect: "",
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const params = ctx.resourceParams.deleteAction;
+  const page = await ctx.client.pages.find(parent_id, ctx.locale);
+
+  if (!page) {
+    throw new Error(`Missing page #${parent_id}`);
+  }
+
+  let redirect = null;
+
+  if (params.redirect === "301" || params.redirect === "410") {
+    redirect = {
+      // TODO: fix url with consideration of locale & defaultLocale in the frontend project
+      url: `/${page.slug}`,
+      destination: params.redirect === "301" ? params.destination : "/",
+      httpResponseCode: Number.parseInt(params.redirect, 10),
+      note: "Created via page deletion process",
+    };
+  }
+
+  const { errors } = await ctx.client.deletePage.delete(
+    page.id,
+    ctx.locale,
+    redirect
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        deleteAction: { ...params, id: page.id },
+        errors: {
+          deleteAction: ctx.client.deletePage.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/pages`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};