@raketa-cloud/admin 0.0.102 → 1.0.0

package/src/cloud/Pages.js

@@ -0,0 +1,185 @@
+import RaketaClient from "./RaketaClient";
+import {
+  ChangePageSlugDocument,
+  ClonePageDocument,
+  CreatePageDocument,
+  DeletePageDocument,
+  MiniPagesDocument,
+  PageByIdDocument,
+  PagesDocument,
+  TranslatePageDocument,
+  buildBatchTranslatePageDocument,
+} from "./documents/pagesDocuments";
+
+export default class Pages extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      tags: [],
+      categories: [],
+      widgets: [],
+      settings: {
+        layout: "default",
+      },
+    };
+  }
+
+  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 listAll(query, locale, pageTypeSlug) {
+    const vars = this.buildAllInput(query, locale);
+
+    const { miniPages: items } = await this.query(MiniPagesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, pageTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async list(query, locale, pageTypeSlug) {
+    const vars = this.buildListInput(query, locale);
+
+    const { pages: items } = await this.query(PagesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, pageTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async create(params, locale, pageTypeSlug) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      createPage: { errors, page },
+    } = await this.query(CreatePageDocument, {
+      input: {
+        locale,
+        page: paramsCopy,
+        pageTypeSlug,
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async clone(id, locale) {
+    const {
+      clonePage: { errors, page },
+    } = await this.query(ClonePageDocument, {
+      input: { id: id, locale: locale },
+    });
+
+    return { page, errors };
+  }
+
+  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 };
+  }
+
+  async translate(id, locale, params) {
+    const copyParams = { ...params };
+
+    copyParams.widgets = JSON.stringify(copyParams.widgets);
+    copyParams.settings = JSON.stringify(copyParams.settings);
+
+    const {
+      translatePage: { errors, page },
+    } = await this.query(TranslatePageDocument, {
+      input: {
+        locale,
+        sourcePageId: id,
+        page: copyParams,
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async translateBatch(sourcePageId, locales, params) {
+    const copyParams = { ...params };
+    copyParams.widgets = JSON.stringify(copyParams.widgets);
+    copyParams.settings = JSON.stringify(copyParams.settings);
+
+    const BatchTranslateDocument = buildBatchTranslatePageDocument(
+      locales.length
+    );
+
+    const variables = {};
+    locales.forEach((locale, i) => {
+      variables[`input${i}`] = {
+        locale,
+        sourcePageId,
+        page: copyParams,
+      };
+    });
+
+    const response = await this.query(BatchTranslateDocument, variables);
+
+    return locales.map((_, i) => {
+      const result = response[`translate${i}`];
+      return {
+        page: result.page,
+        errors: result.errors,
+      };
+    });
+  }
+
+  async updateSlug(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/RaketaClient.js

@@ -0,0 +1,223 @@
+import { request } from "graphql-request";
+
+function isObjectEmpty(obj) {
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) return false;
+  }
+
+  return true;
+}
+
+function deepMerge(target, updates) {
+  if (typeof target !== "object" || target === null) {
+    return updates;
+  }
+
+  if (typeof updates !== "object" || updates === null) {
+    return target;
+  }
+
+  for (let key of Object.keys(updates)) {
+    if (Array.isArray(updates[key])) {
+      if (!Array.isArray(target[key])) {
+        target[key] = [];
+      }
+      target[key] = updates[key];
+    } else if (typeof updates[key] === "object" && updates[key] !== null) {
+      if (!target[key] || typeof target[key] !== "object") {
+        target[key] = {};
+      }
+      target[key] = deepMerge(target[key], updates[key]);
+    } else {
+      target[key] = updates[key];
+    }
+  }
+
+  return target;
+}
+
+function parseJson(str) {
+  if (!str) {
+    return str;
+  }
+
+  try {
+    const res = JSON.parse(str);
+
+    if (typeof res === "object") {
+      return res;
+    }
+
+    return str;
+  } catch (e) {
+    return str;
+  }
+}
+
+function parseJsonFields(params) {
+  if (!params) {
+    return params;
+  }
+
+  if (typeof params === "string") {
+    return parseJson(params);
+  }
+
+  for (let key of Object.keys(params)) {
+    if (typeof params[key] === "string") {
+      params[key] = parseJson(params[key]);
+    }
+
+    if (Array.isArray(params[key])) {
+      params[key] = params[key].map((item) => parseJsonFields(item));
+    }
+
+    if (typeof params[key] === "object") {
+      params[key] = parseJsonFields(params[key]);
+    }
+  }
+
+  return params;
+}
+
+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().cloud.gateway_url}/dispatch`,
+      query,
+      variables,
+      {
+        "x-raketa-project": this.getConfig().cloud.gateway_project,
+        "x-raketa-service": this.getConfig().cloud.dxp_service_private,
+        "x-raketa-identity": this.token,
+      }
+    );
+  }
+
+  logError(message, ctx) {
+    if (ctx) console.error(ctx);
+    throw new Error(message);
+  }
+
+  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;
+  }
+
+  buildAllInput(query, locale = null) {
+    const orderBy = this.buildOrderInput(query);
+    const variables = {
+      input: {
+        filters: this.buildFiltersInput(query),
+      },
+    };
+
+    if (orderBy) {
+      variables.input.orderBy = orderBy;
+    }
+
+    if (locale) {
+      variables.input.locale = locale;
+    }
+
+    return variables;
+  }
+
+  deepMerge(target, source) {
+    return parseJsonFields(deepMerge(structuredClone(target), source));
+  }
+}

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/Settings.js

@@ -0,0 +1,28 @@
+import RaketaClient from "./RaketaClient";
+import {
+  UpdateSettingDocument,
+  SettingDocument,
+} from "./documents/settingsDocuments";
+
+export default class Settings extends RaketaClient {
+  async find(locale) {
+    const { setting } = await this.query(SettingDocument, {
+      locale,
+    });
+
+    return setting?.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 };
+  }
+}