@raketa-cloud/admin 0.0.100 → 0.0.102

package/src/cloud/Pages.js

@@ -1,185 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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 };
-  }
-}