@raketa-cloud/admin 0.0.7 → 0.0.8

package/src/handlers/RedirectsHandler.js

@@ -0,0 +1,124 @@
+const index = async (ctx) => {
+  const items = await ctx.client.redirects.list(ctx.query);
+
+  return {
+    assigns: {
+      items,
+    },
+  };
+};
+
+const show = async (ctx) => {
+  const { id } = ctx.params;
+  const item = await ctx.client.redirects.find(id);
+  const history = await ctx.client.redirects.history(id);
+
+  return {
+    assigns: {
+      item,
+      history,
+    },
+  };
+};
+
+const create_form = (_ctx) => {
+  return {
+    assigns: {
+      redirect: {},
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const edit_form = async (ctx) => {
+  const { id } = ctx.params;
+  const redirect = await ctx.client.redirects.find(id);
+
+  return {
+    assigns: {
+      id,
+      redirect,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const params = ctx.resourceParams.redirect;
+
+  const { errors } = await ctx.client.redirects.create({
+    url: params.url,
+    destination: params.destination,
+    httpResponseCode: Number.parseInt(params.httpResponseCode, 10),
+    note: params.note || "",
+  });
+
+  if (errors) {
+    return {
+      assigns: {
+        redirect: params,
+        errors: { redirect: ctx.client.redirects.formatErrors(errors) },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/redirects`,
+  };
+};
+
+const update = async (ctx) => {
+  const { id } = ctx.params;
+  const params = ctx.resourceParams.redirect;
+
+  const { errors } = await ctx.client.redirects.update(id, {
+    url: params.url,
+    destination: params.destination,
+    httpResponseCode: Number.parseInt(params.httpResponseCode, 10),
+    note: params.note || "",
+  });
+
+  if (errors) {
+    return {
+      assigns: {
+        redirect: { ...params, id },
+        errors: { redirect: ctx.client.redirects.formatErrors(errors) },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/redirects`,
+  };
+};
+
+const destroy = async (ctx) => {
+  const { id } = ctx.params;
+
+  const { errors } = await ctx.client.redirects.delete(id);
+
+  if (errors) {
+    throw `Failed to delete redirect #${id}. WTF?`;
+  }
+
+  return {
+    headers: {
+      "HX-Redirect": `/${ctx.locale}/redirects`,
+    },
+    json: {},
+  };
+};
+
+export default {
+  index,
+  show,
+  create_form,
+  edit_form,
+  create,
+  update,
+  destroy,
+};

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

@@ -0,0 +1,84 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+function buildCtx(redirect) {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    resourceParams: {
+      redirect: {
+        url: redirect.url,
+        destination: redirect.destination,
+        httpResponseCode: redirect.httpResponseCode.toString(),
+        note: redirect.note,
+      },
+    },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("create successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockCreate = jest
+      .spyOn(ctx.client.redirects, "create")
+      .mockImplementation(() => ({ redirect: redirect, errors: null }));
+
+    const result = await RedirectsHandler.create(ctx);
+
+    expect(mockCreate).toHaveBeenCalledWith({
+      url: redirect.url,
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      redirect: "/en/redirects",
+    });
+  });
+
+  test("create failed", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockCreate = jest
+      .spyOn(ctx.client.redirects, "create")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "url", message: "already used" }],
+      }));
+
+    const result = await RedirectsHandler.create(ctx);
+
+    expect(mockCreate).toHaveBeenCalledWith({
+      url: redirect.url,
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {
+          url: redirect.url,
+          destination: redirect.destination,
+          httpResponseCode: redirect.httpResponseCode.toString(),
+          note: redirect.note,
+        },
+        errors: {
+          redirect: {
+            url: "already used",
+          },
+        },
+        _translations: [],
+      },
+    });
+  });
+});

package/src/handlers/RedirectsHandler.test/create_form.test.js

@@ -0,0 +1,29 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("create_form", async () => {
+    const ctx = buildCtx();
+
+    const result = RedirectsHandler.create_form(ctx);
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {},
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/handlers/RedirectsHandler.test/destroy.test.js

@@ -0,0 +1,54 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    params: { id: 1 },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("destroy successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx();
+
+    const mockDelete = jest
+      .spyOn(ctx.client.redirects, "delete")
+      .mockImplementation(() => ({ redirect: redirect, errors: null }));
+
+    const result = await RedirectsHandler.destroy(ctx);
+
+    expect(mockDelete).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      headers: {
+        "HX-Redirect": "/en/redirects",
+      },
+      json: {},
+    });
+  });
+
+  test("destroy failed", async () => {
+    const ctx = buildCtx();
+
+    const mockDelete = jest
+      .spyOn(ctx.client.redirects, "delete")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "generalError", message: "Not found" }],
+      }));
+
+    await expect(() => RedirectsHandler.destroy(ctx)).rejects.toMatch(
+      "Failed to delete redirect #1. WTF?"
+    );
+
+    expect(mockDelete).toHaveBeenCalledWith(1);
+  });
+});

package/src/handlers/RedirectsHandler.test/edit_form.test.js

@@ -0,0 +1,38 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("edit_form", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx();
+
+    const mockShow = jest
+      .spyOn(ctx.client.redirects, "find")
+      .mockImplementation(() => redirect);
+
+    const result = await RedirectsHandler.edit_form(ctx);
+
+    expect(mockShow).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      assigns: {
+        id: 1,
+        redirect: redirect,
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/handlers/RedirectsHandler.test/index.test.js

@@ -0,0 +1,42 @@
+import RedirectsHandler from "./../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+describe("Redirects", () => {
+  function buildCtx() {
+    return {
+      client: {
+        redirects: new Redirects(testConfig, "token"),
+      },
+      query: { foo: "bar" },
+      req: {
+        path: "/redirects",
+      },
+    };
+  }
+
+  test("index", async () => {
+    const redirect = Factory.build("redirect");
+    const pagination = Factory.build("pagination");
+    const ctx = buildCtx();
+
+    const mockedList = jest
+      .spyOn(ctx.client.redirects, "list")
+      .mockImplementation(() => ({ list: [redirect], pagination }));
+
+    const result = await RedirectsHandler.index(ctx);
+
+    expect(mockedList).toHaveBeenCalledWith({ foo: "bar" });
+
+    expect(result).toEqual({
+      assigns: {
+        items: {
+          list: [redirect],
+          pagination: pagination,
+        },
+      },
+    });
+  });
+});

package/src/handlers/RedirectsHandler.test/show.test.js

@@ -0,0 +1,41 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("show", async () => {
+    const redirect = Factory.build("redirect");
+
+    const ctx = buildCtx();
+
+    const mockShow = jest
+      .spyOn(ctx.client.redirects, "find")
+      .mockImplementation(() => redirect);
+
+    const mockHistory = jest
+      .spyOn(ctx.client.redirects, "history")
+      .mockImplementation(() => []);
+
+    const result = await RedirectsHandler.show(ctx);
+
+    expect(mockShow).toHaveBeenCalledWith(1);
+    expect(mockHistory).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      assigns: {
+        item: redirect,
+        history: [],
+      },
+    });
+  });
+});

package/src/handlers/RedirectsHandler.test/update.test.js

@@ -0,0 +1,89 @@
+import RedirectsHandler from "../RedirectsHandler";
+import Redirects from "../../cloud/Redirects";
+
+import { testConfig } from "../../../test/handlersHelper";
+import Factory from "../../../test/factory";
+
+function buildCtx(redirect) {
+  return {
+    client: {
+      redirects: new Redirects(testConfig, "token"),
+    },
+    params: { id: redirect.id },
+    resourceParams: {
+      redirect: {
+        url: "/updated",
+        destination: redirect.destination,
+        httpResponseCode: redirect.httpResponseCode.toString(),
+        note: redirect.note,
+      },
+    },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("update successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.redirects, "update")
+      .mockImplementation(() => ({
+        redirect: { ...redirect, url: "/updated" },
+        errors: null,
+      }));
+
+    const result = await RedirectsHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(redirect.id, {
+      url: "/updated",
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      redirect: "/en/redirects",
+    });
+  });
+
+  test("update failed", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.redirects, "update")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "url", message: "already used" }],
+      }));
+
+    const result = await RedirectsHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(redirect.id, {
+      url: "/updated",
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {
+          id: redirect.id,
+          url: "/updated",
+          destination: redirect.destination,
+          httpResponseCode: redirect.httpResponseCode.toString(),
+          note: redirect.note,
+        },
+        errors: {
+          redirect: {
+            url: "already used",
+          },
+        },
+        _translations: [],
+      },
+    });
+  });
+});

package/src/handlers/RevertPageRevisionHandler.js

@@ -0,0 +1,26 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { version } = ctx.resourceParams;
+
+  const { errors, pageErrors } = await ctx.client.revertPageRevision.create(
+    parent_id,
+    Number.parseInt(version, 10),
+    ctx.locale
+  );
+
+  if (errors) {
+    throw new Error(`Failed to start revision: ${JSON.stringify(errors)}`);
+  }
+
+  if (pageErrors) {
+    throw new Error(`Failed to start revision: ${JSON.stringify(pageErrors)}`);
+  }
+
+  return {
+    redirect: `/${ctx.locale}/pages/${parent_id}`,
+  };
+};
+
+export default {
+  create,
+};

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

@@ -0,0 +1,80 @@
+import RevertPageRevisionHandler from "../RevertPageRevisionHandler";
+import RevertPageRevision from "../../cloud/RevertPageRevision";
+import { testConfig } from "../../../../../apps/admin/test/handlersHelper";
+
+function buildCtx(pageID, version) {
+  return {
+    client: {
+      revertPageRevision: new RevertPageRevision(testConfig, "token"),
+    },
+    params: { parent_id: pageID },
+    resourceParams: { version },
+    locale: "en",
+  };
+}
+
+describe("Page revision revert", () => {
+  test("create successful", async () => {
+    const pageId = 42;
+    const version = 2;
+    const ctx = buildCtx(pageId, version);
+
+    const mockRevert = jest
+      .spyOn(ctx.client.revertPageRevision, "create")
+      .mockImplementation(() => ({
+        revision: {},
+        errors: null,
+        pageErrors: null,
+      }));
+
+    const result = await RevertPageRevisionHandler.create(ctx);
+
+    expect(mockRevert).toHaveBeenCalledWith(pageId, version, "en");
+
+    expect(result).toEqual({
+      redirect: `/en/pages/${pageId}`,
+    });
+  });
+
+  test("create failed with errors", async () => {
+    const pageId = 42;
+    const version = 2;
+    const ctx = buildCtx(pageId, version);
+    const errors = [{ key: "generalError", message: "Some error" }];
+
+    const mockRevert = jest
+      .spyOn(ctx.client.revertPageRevision, "create")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: errors,
+        pageErrors: null,
+      }));
+
+    expect(async () => {
+      await RevertPageRevisionHandler.create(ctx);
+    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+
+    expect(mockRevert).toHaveBeenCalledWith(pageId, version, "en");
+  });
+
+  test("create failed with page errors", async () => {
+    const pageId = 42;
+    const version = 2;
+    const ctx = buildCtx(pageId, version);
+    const errors = [{ key: "generalError", message: "Some error" }];
+
+    const mockRevert = jest
+      .spyOn(ctx.client.revertPageRevision, "create")
+      .mockImplementation(() => ({
+        revision: null,
+        errors: null,
+        pageErrors: errors,
+      }));
+
+    expect(async () => {
+      await RevertPageRevisionHandler.create(ctx);
+    }).rejects.toThrow(`Failed to start revision: ${JSON.stringify(errors)}`);
+
+    expect(mockRevert).toHaveBeenCalledWith(pageId, version, "en");
+  });
+});

package/src/handlers/SettingsGeneralHandler.js

@@ -0,0 +1,13 @@
+const edit_form = async (ctx) => {
+  const settings = await ctx.client.settings.find(ctx.locale);
+
+  return {
+    assigns: {
+      settings,
+    },
+  };
+};
+
+export default {
+  edit_form,
+};

package/src/handlers/SettingsLayoutHandler.js

@@ -0,0 +1,51 @@
+const edit_form = async (ctx) => {
+  const data = await ctx.client.settings.find(ctx.locale);
+
+  const layout_settings = {
+    header: JSON.stringify(data.menus?.header),
+    footer: JSON.stringify(data.menus?.footer),
+  };
+
+  return {
+    assigns: {
+      errors: {},
+      layout_settings,
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const params = ctx.resourceParams.layout_settings;
+
+  const currentSettings = await ctx.client.settings.find(ctx.locale);
+
+  if (!currentSettings.menus) {
+    currentSettings.menus = {};
+  }
+
+  currentSettings.menus.header = JSON.parse(params.header);
+  currentSettings.menus.footer = JSON.parse(params.footer);
+
+  const { errors } = await ctx.client.settings.update(
+    ctx.locale,
+    currentSettings
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        setting: { ...params },
+        errors: { setting: ctx.client.settings.formatErrors(errors) },
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/settings/layout/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};