@raketa-cloud/admin 0.0.6 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "src/index.js",
   "scripts": {
     "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",
@@ -19,6 +19,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "ejs": "^3.1.10"
+    "ejs": "^3.1.10",
+    "graphql-request": "5.1.0"
   }
 }

package/src/Adapter.js

@@ -1,5 +1,5 @@
-import nodePath from "node:path";
 import { existsSync } from "node:fs";
+import nodePath from "node:path";
 import ejs from "ejs";
 import FormBuilder from "./helpers/FormBuilder";
 import HTMLBuilder from "./helpers/HTMLBuilder";

package/src/cloud/ChangePageURL.js

@@ -0,0 +1,24 @@
+import RaketaClient from "./RaketaClient";
+import { ChangePageSlugDocument } from "./documents/pagesDocuments";
+
+export default class ChangePageURL extends RaketaClient {
+  async update(id, slug, locale, redirect) {
+    const input = {
+      id,
+      slug,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      changePageSlug: { errors, page },
+    } = await this.query(ChangePageSlugDocument, {
+      input,
+    });
+
+    return { page, errors };
+  }
+}

package/src/cloud/ClonesPage.js

@@ -0,0 +1,14 @@
+import RaketaClient from "./RaketaClient";
+import { ClonePageDocument } from "./documents/pagesDocuments";
+
+export default class ClonePage extends RaketaClient {
+  async clone(id, locale) {
+    const {
+      clonePage: { errors, page },
+    } = await this.query(ClonePageDocument, {
+      input: { id: id, locale: locale },
+    });
+
+    return { page, errors };
+  }
+}

package/src/cloud/DeletePage.js

@@ -0,0 +1,35 @@
+import RaketaClient from "./RaketaClient";
+import {
+  DeletePageDocument,
+  PageByIdDocument,
+} from "./documents/pagesDocuments";
+
+export default class DeletePage extends RaketaClient {
+  async find(id, locale) {
+    const { page: item } = await this.query(PageByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async delete(id, locale, redirect) {
+    const input = {
+      id,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      deletePage: { errors, page },
+    } = await this.query(DeletePageDocument, { input });
+
+    return { page, errors };
+  }
+}

package/src/cloud/PageChanges.js

@@ -0,0 +1,15 @@
+import RaketaClient from "./RaketaClient";
+import { PageChangesDocument } from "./documents/pagesDocuments";
+
+export default class PageChanges extends RaketaClient {
+  async all(pageId, locale) {
+    const { pageChanges: items } = await this.query(PageChangesDocument, {
+      input: {
+        id: pageId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+}

package/src/cloud/PageRevisions.js

@@ -0,0 +1,135 @@
+import RaketaClient from "./RaketaClient";
+import {
+  DeletePageDocument,
+  LockPageRevisionDocument,
+  MergePageRevisionDocument,
+  PageByIdDocument,
+  PageRevisionDocument,
+  PageRevisionsDocument,
+  StartPageRevisionDocument,
+  UnlockPageRevisionDocument,
+  UpdatePageDocument,
+  UpdatePageWidgetsDocument,
+} from "./documents/pagesDocuments";
+
+export default class PageRevisions extends RaketaClient {
+  async all(pageId, locale) {
+    const { pageRevisions: items } = await this.query(PageRevisionsDocument, {
+      input: {
+        id: pageId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { pageRevision } = await this.query(PageRevisionDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return pageRevision;
+  }
+
+  async publish(id, locale, params, pageParams) {
+    const {
+      mergePageRevision: { page, errors },
+    } = await this.query(MergePageRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        page: { ...pageParams },
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async create(pageId, locale) {
+    const {
+      startPageRevision: { revision, errors, pageErrors },
+    } = await this.query(StartPageRevisionDocument, {
+      input: {
+        id: pageId,
+        locale,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+
+  async update(id, locale, params) {
+    const {
+      updatePage: { errors, page },
+    } = await this.query(UpdatePageDocument, {
+      input: {
+        id,
+        locale,
+        page: params,
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async updateWidgets(id, locale, widgets) {
+    const {
+      updatePageWidgets: { errors, page },
+    } = await this.query(UpdatePageWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async delete(revisionId, locale) {
+    const {
+      deletePage: { page, errors },
+    } = await this.query(DeletePageDocument, {
+      input: {
+        id: revisionId,
+        locale,
+      },
+    });
+
+    return { revision: page, errors };
+  }
+
+  async lock(revisionId, locale, message) {
+    const {
+      lockPageRevision: { revision, errors },
+    } = await this.query(LockPageRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale) {
+    const {
+      unlockPageRevision: { revision, errors },
+    } = await this.query(UnlockPageRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+}

package/src/cloud/PageTranslations.js

@@ -0,0 +1,22 @@
+import RaketaClient from "./RaketaClient";
+import { TranslatePageDocument } from "./documents/pagesDocuments";
+
+export default class PageTranslations extends RaketaClient {
+  async create(locale, sourcePageId, params) {
+    console.log(params);
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+    console.log(params);
+    const {
+      translatePage: { errors, page },
+    } = await this.query(TranslatePageDocument, {
+      input: {
+        locale,
+        sourcePageId,
+        page: params,
+      },
+    });
+
+    return { page, errors };
+  }
+}

package/src/cloud/Pages.js

@@ -0,0 +1,63 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CreatePageDocument,
+  PageByIdDocument,
+  PagesDocument,
+} from "./documents/pagesDocuments";
+
+export default class Pages extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      layout: "default",
+      tags: [],
+      categories: [],
+    };
+  }
+
+  visibilityOptions() {
+    return [
+      ["private", "Private"],
+      ["public", "Public"],
+      ["unlisted", "Unlisted"],
+      ["protected", "Password protected"],
+    ];
+  }
+
+  async find(id, locale) {
+    const { page: item } = await this.query(PageByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async list(query, locale) {
+    const { pages: items } = await this.query(
+      PagesDocument,
+      this.buildListInput(query, locale)
+    );
+
+    return items;
+  }
+
+  async create(params, locale, pageTypeSlug) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      createPage: { errors, page },
+    } = await this.query(CreatePageDocument, {
+      input: {
+        locale,
+        page: params,
+        pageTypeSlug,
+      },
+    });
+
+    return { page, errors };
+  }
+}

package/src/cloud/RaketaClient.js

@@ -0,0 +1,118 @@
+import { request } from "graphql-request";
+
+function isObjectEmpty(obj) {
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) return false;
+  }
+
+  return true;
+}
+
+export default class RaketaClient {
+  constructor(getConfig, token) {
+    this.getConfig = getConfig;
+    this.token = token;
+  }
+
+  gqlRequest(url, query, variables = {}, headers = {}) {
+    return request({
+      url,
+      document: query,
+      variables: variables,
+      requestHeaders: headers,
+    });
+  }
+
+  query(query, variables = {}) {
+    return this.gqlRequest(this.getConfig().instanceURL, query, variables, {
+      "x-raketa-project": this.getConfig().project,
+      "x-raketa-service": this.getConfig().service,
+      "x-raketa-identity": this.token,
+    });
+  }
+
+  formatErrors(errors, generalErrorTo = null) {
+    const result = {};
+
+    errors.forEach((error) => {
+      const key =
+        generalErrorTo && error.key === "generalError"
+          ? generalErrorTo
+          : error.key;
+
+      if (!result[key]) {
+        result[key] = [];
+      }
+
+      result[key].push(error.message);
+    });
+
+    Object.keys(result).forEach((key) => {
+      result[key] = result[key].join(", ");
+    });
+
+    return { ...result };
+  }
+
+  buildFiltersInput(query) {
+    if (!query) {
+      return {};
+    }
+
+    const { page, ...rest } = query;
+
+    if (isObjectEmpty(rest)) {
+      return {};
+    }
+    const filters = {};
+
+    for (const key in rest) {
+      const stringKey = key.toString();
+
+      if (stringKey.startsWith("f:") && rest[key]) {
+        filters[stringKey.slice(2)] = rest[key];
+      }
+    }
+
+    return filters;
+  }
+
+  buildOrderInput(query) {
+    const orderBy = query.order_by || "";
+
+    if (!orderBy) {
+      return null;
+    }
+
+    return {
+      field: orderBy,
+      direction: query.order_direction || "ASC",
+    };
+  }
+
+  buildPaginationInput(query) {
+    const page = Number.parseInt(query.page || "1", 10);
+
+    return { page: page, pageSize: 25 };
+  }
+
+  buildListInput(query, locale = null) {
+    const orderBy = this.buildOrderInput(query);
+    const variables = {
+      input: {
+        pagination: this.buildPaginationInput(query),
+        filters: this.buildFiltersInput(query),
+      },
+    };
+
+    if (orderBy) {
+      variables.input.orderBy = orderBy;
+    }
+
+    if (locale) {
+      variables.input.locale = locale;
+    }
+
+    return variables;
+  }
+}

package/src/cloud/Redirects.js

@@ -0,0 +1,81 @@
+import RaketaClient from "./RaketaClient";
+import {
+  RedirectByIdDocument,
+  RedirectChangesDocument,
+  RedirectsDocument,
+  CreateRedirectDocument,
+  UpdateRedirectDocument,
+  DeleteRedirectDocument,
+} from "./documents/redirectsDocuments";
+
+export default class Redirects extends RaketaClient {
+  async list(query) {
+    const { redirects: items } = await this.query(
+      RedirectsDocument,
+      this.buildListInput(query)
+    );
+
+    return items;
+  }
+
+  async find(id) {
+    const { redirect: item } = await this.query(RedirectByIdDocument, {
+      input: {
+        id,
+      },
+    });
+
+    return item;
+  }
+
+  async create(params) {
+    const {
+      createRedirect: { errors, redirect },
+    } = await this.query(CreateRedirectDocument, {
+      input: {
+        redirect: params,
+      },
+    });
+
+    return { redirect, errors };
+  }
+
+  async update(id, params) {
+    const {
+      updateRedirect: { errors, redirect },
+    } = await this.query(UpdateRedirectDocument, {
+      input: {
+        id,
+        redirect: params,
+      },
+    });
+
+    return { redirect, errors };
+  }
+
+  async delete(id) {
+    const {
+      deleteRedirect: { errors, redirect },
+    } = await this.query(DeleteRedirectDocument, {
+      input: {
+        id,
+      },
+    });
+
+    return { redirect, errors };
+  }
+
+  async history(id) {
+    const { redirectChanges: items } = await this.query(
+      RedirectChangesDocument,
+      {
+        input: {
+          id,
+          locale: "en",
+        },
+      }
+    );
+
+    return items;
+  }
+}

package/src/cloud/RevertPageRevision.js

@@ -0,0 +1,18 @@
+import RaketaClient from "./RaketaClient";
+import { ReopenPageChangeDocument } from "./documents/pagesDocuments";
+
+export default class RevertPageRevision extends RaketaClient {
+  async create(pageId, version, locale) {
+    const {
+      reopenPageChange: { revision, errors, pageErrors },
+    } = await this.query(ReopenPageChangeDocument, {
+      input: {
+        pageId,
+        locale,
+        version,
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+}

package/src/cloud/Settings.js

@@ -0,0 +1,30 @@
+import RaketaClient from "./RaketaClient";
+import {
+  UpdateSettingDocument,
+  SettingDocument,
+} from "./documents/settingsDocuments";
+
+export default class Settings extends RaketaClient {
+  async find(locale) {
+    const {
+      setting: { value },
+    } = await this.query(SettingDocument, {
+      locale,
+    });
+
+    return value;
+  }
+
+  async update(locale, params) {
+    const {
+      updateSetting: { errors, setting },
+    } = await this.query(UpdateSettingDocument, {
+      input: {
+        locale,
+        setting: { value: JSON.stringify(params) },
+      },
+    });
+
+    return { setting, errors };
+  }
+}

package/src/cloud/Tags.js

@@ -0,0 +1,80 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CreateTagDocument,
+  DeleteTagDocument,
+  TagByIdDocument,
+  TagsDocument,
+  UpdateTagDocument,
+} from "./documents/tagsDocuments";
+
+export default class Tags extends RaketaClient {
+  async list(query, locale) {
+    const { tags: items } = await this.query(
+      TagsDocument,
+      this.buildListInput(query, locale)
+    );
+
+    return items;
+  }
+
+  async all(locale) {
+    const { tags: items } = await this.query(TagsDocument, {
+      input: {
+        locale: locale,
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { tag: item } = await this.query(TagByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async create(params, locale) {
+    const {
+      createTag: { errors, tag },
+    } = await this.query(CreateTagDocument, {
+      input: {
+        locale,
+        tag: params,
+      },
+    });
+
+    return { tag, errors };
+  }
+
+  async update(id, params, locale) {
+    const {
+      updateTag: { errors, tag },
+    } = await this.query(UpdateTagDocument, {
+      input: {
+        id,
+        locale,
+        tag: params,
+      },
+    });
+
+    return { tag, errors };
+  }
+
+  async delete(id, locale) {
+    const {
+      deleteTag: { errors, tag },
+    } = await this.query(DeleteTagDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return { tag, errors };
+  }
+}