@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/cloud/ArticleChanges.js

@@ -0,0 +1,36 @@
+import RaketaClient from "./RaketaClient";
+
+import {
+  ArticleHistoryDocument,
+  ArticleEditorsDocument,
+} from "./documents/articlesDocuments";
+
+export default class ArticleChanges extends RaketaClient {
+  async list(query, articleId, locale) {
+    const vars = this.buildListInput(query, locale);
+
+    const { articleHistory: items } = await this.query(ArticleHistoryDocument, {
+      input: {
+        ...vars.input,
+        id: articleId,
+        locale,
+        pagination: {
+          ...(vars.input.pagination || {}),
+        },
+      },
+    });
+
+    return items;
+  }
+
+  async all_editors(articleId, locale) {
+    const { articleEditors } = await this.query(ArticleEditorsDocument, {
+      input: {
+        id: articleId,
+        locale,
+      },
+    });
+
+    return articleEditors?.list;
+  }
+}

package/src/cloud/ArticleRevisions.js

@@ -0,0 +1,239 @@
+import { toUTCISO8601String } from "../utils";
+import RaketaClient from "./RaketaClient";
+import {
+  ArticleRevisionDocument,
+  ArticleRevisionsDocument,
+  CancelArticleRevisionScheduleDocument,
+  buildBatchStartArticleRevisionDocument,
+  DeleteArticleDocument,
+  LockArticleRevisionDocument,
+  MergeArticleRevisionDocument,
+  ReopenArticleChangeDocument,
+  ScheduleArticleRevisionDocument,
+  StartArticleRevisionDocument,
+  UnlockArticleRevisionDocument,
+  UpdateArticleDocument,
+  UpdateArticleWidgetsDocument,
+} from "./documents/articlesDocuments";
+
+export default class ArticleRevisions extends RaketaClient {
+  selectUpdateParams(revision) {
+    return {
+      title: revision.title,
+      slug: revision.slug,
+      publishAt: revision.publishAt,
+      widgets: [...revision.widgets],
+      settings: {
+        ...revision.settings,
+      },
+      visibility: revision.visibility,
+      tags: revision.tags.map((t) => (t.id ? t.id : t)),
+      categories: revision.categories.map((c) => (c.id ? c.id : c)),
+    };
+  }
+
+  formatDates(params) {
+    if (params.publishAt) {
+      params.publishAt = toUTCISO8601String(params.publishAt);
+    }
+
+    return { ...params };
+  }
+
+  async all(articleId, locale) {
+    const { articleRevisions: items } = await this.query(
+      ArticleRevisionsDocument,
+      {
+        input: {
+          id: articleId,
+          locale,
+        },
+      }
+    );
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { articleRevision } = await this.query(ArticleRevisionDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return articleRevision;
+  }
+
+  async publish(id, locale, params, articleParams) {
+    const {
+      mergeArticleRevision: { article, errors },
+    } = await this.query(MergeArticleRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        article: { ...articleParams },
+      },
+    });
+
+    return { article, errors };
+  }
+
+  async schedule(id, locale, params, articleParams) {
+    const {
+      scheduleArticleRevision: { revision, errors, articleErrors },
+    } = await this.query(ScheduleArticleRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        article: { ...articleParams },
+      },
+    });
+
+    return { revision, errors, articleErrors };
+  }
+
+  async cancelSchedule(id, locale) {
+    const {
+      cancelArticleRevisionSchedule: { revision, errors, articleErrors },
+    } = await this.query(CancelArticleRevisionScheduleDocument, {
+      input: {
+        revisionId: id,
+        locale: locale,
+      },
+    });
+
+    return { revision, errors, articleErrors };
+  }
+
+  async create(articleId, locale) {
+    const {
+      startArticleRevision: { revision, errors, articleErrors },
+    } = await this.query(StartArticleRevisionDocument, {
+      input: {
+        id: articleId,
+        locale,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, articleErrors };
+  }
+
+  async createBatch(revisionInputs) {
+    const BatchDocument = buildBatchStartArticleRevisionDocument(
+      revisionInputs.length
+    );
+
+    const variables = {};
+    revisionInputs.forEach((input, i) => {
+      variables[`input${i}`] = {
+        id: input.articleId,
+        locale: input.locale,
+        title: "New revision",
+        description: "",
+      };
+    });
+
+    const response = await this.query(BatchDocument, variables);
+
+    return revisionInputs.map((_, i) => {
+      const result = response[`startRevision${i}`];
+      return {
+        revision: result.revision,
+        errors: result.errors,
+        articleErrors: result.articleErrors,
+      };
+    });
+  }
+
+  async update(id, locale, params) {
+    const copyParams = { ...params };
+
+    copyParams.widgets = JSON.stringify(params.widgets || []);
+    copyParams.settings = JSON.stringify(params.settings || {});
+
+    const {
+      updateArticle: { errors, article },
+    } = await this.query(UpdateArticleDocument, {
+      input: {
+        id,
+        locale,
+        article: copyParams,
+      },
+    });
+
+    return { article, errors };
+  }
+
+  async updateWidgets(id, locale, widgets) {
+    const {
+      updateArticleWidgets: { errors, article },
+    } = await this.query(UpdateArticleWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { article, errors };
+  }
+
+  async delete(revisionId, locale) {
+    const {
+      deleteArticle: { article, errors },
+    } = await this.query(DeleteArticleDocument, {
+      input: {
+        id: revisionId,
+        locale,
+      },
+    });
+
+    return { revision: article, errors };
+  }
+
+  async lock(revisionId, locale, message) {
+    const {
+      lockArticleRevision: { revision, errors },
+    } = await this.query(LockArticleRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale) {
+    const {
+      unlockArticleRevision: { revision, errors },
+    } = await this.query(UnlockArticleRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async revert(articleId, version, locale) {
+    const {
+      reopenArticleChange: { revision, errors, articleErrors },
+    } = await this.query(ReopenArticleChangeDocument, {
+      input: {
+        articleId,
+        locale,
+        version,
+      },
+    });
+
+    return { revision, errors, articleErrors };
+  }
+}

package/src/cloud/Articles.js

@@ -0,0 +1,194 @@
+import { toDateTimeInput, toUTCISO8601String } from "../utils";
+import RaketaClient from "./RaketaClient";
+import {
+  ArticleByIdDocument,
+  ArticlesDocument,
+  ChangeArticleSlugDocument,
+  CloneArticleDocument,
+  CreateArticleDocument,
+  buildBatchTranslateArticleDocument,
+  DeleteArticleDocument,
+  MiniArticlesDocument,
+  TranslateArticleDocument,
+} from "./documents/articlesDocuments";
+
+export default class Articles extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      publishAt: toDateTimeInput(new Date()),
+      settings: {
+        layout: "default",
+      },
+      widgets: [],
+      tags: [],
+      categories: [],
+    };
+  }
+
+  formatDates(params) {
+    if (params.publishAt) {
+      params.publishAt = toUTCISO8601String(params.publishAt);
+    }
+
+    return { ...params };
+  }
+
+  visibilityOptions() {
+    return [
+      ["private", "Private"],
+      ["public", "Public"],
+      ["unlisted", "Unlisted"],
+      ["protected", "Password protected"],
+    ];
+  }
+
+  async find(id, locale) {
+    const { article: item } = await this.query(ArticleByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async listAll(query, locale, articleTypeSlug) {
+    const vars = this.buildAllInput(query, locale);
+
+    const { miniArticles: items } = await this.query(MiniArticlesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, articleTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async list(query, locale, articleTypeSlug) {
+    const vars = this.buildListInput(query, locale);
+
+    const { articles: items } = await this.query(ArticlesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, articleTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async create(params, locale, articleTypeSlug) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      createArticle: { errors, article },
+    } = await this.query(CreateArticleDocument, {
+      input: {
+        locale,
+        article: paramsCopy,
+        articleTypeSlug,
+      },
+    });
+
+    return { article, errors };
+  }
+
+  async clone(id, locale) {
+    const {
+      cloneArticle: { errors, article },
+    } = await this.query(CloneArticleDocument, {
+      input: { id: id, locale: locale },
+    });
+
+    return { article, errors };
+  }
+
+  async delete(id, locale, redirect) {
+    const input = {
+      id,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      deleteArticle: { errors, article },
+    } = await this.query(DeleteArticleDocument, { input });
+
+    return { article, errors };
+  }
+
+  async translate(id, locale, params) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      translateArticle: { errors, article },
+    } = await this.query(TranslateArticleDocument, {
+      input: {
+        locale,
+        sourceArticleId: id,
+        article: paramsCopy,
+      },
+    });
+
+    return { article, errors };
+  }
+
+  async translateBatch(sourceArticleId, locales, params) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const BatchTranslateDocument = buildBatchTranslateArticleDocument(
+      locales.length
+    );
+
+    const variables = {};
+    locales.forEach((locale, i) => {
+      variables[`input${i}`] = {
+        locale,
+        sourceArticleId,
+        article: paramsCopy,
+      };
+    });
+
+    const response = await this.query(BatchTranslateDocument, variables);
+
+    return locales.map((_, i) => {
+      const result = response[`translate${i}`];
+      return {
+        article: result.article,
+        errors: result.errors,
+      };
+    });
+  }
+
+  async updateSlug(id, slug, locale, redirect) {
+    const input = {
+      id,
+      slug,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      changeArticleSlug: { errors, article },
+    } = await this.query(ChangeArticleSlugDocument, {
+      input,
+    });
+
+    return { article, errors };
+  }
+}

package/src/cloud/Categories.js

@@ -0,0 +1,97 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CategoriesDocument,
+  CategoryDocument,
+  CreateCategoryDocument,
+  UpdateCategoryDocument,
+  DeleteCategoryDocumet,
+} from "./documents/categoryDocuments";
+
+export default class Categories extends RaketaClient {
+  async list(query, locale, categoryType) {
+    const vars = this.buildListInput(query, locale);
+
+    const { categories: items } = await this.query(CategoriesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, type: categoryType },
+      },
+    });
+
+    return items;
+  }
+
+  async all(query, locale, categoryType) {
+    const vars = this.buildAllInput(query, locale);
+
+    const { categories: items } = await this.query(CategoriesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, type: categoryType },
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { category: item } = await this.query(CategoryDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async create(params, locale, categoryType) {
+    const {
+      createCategory: { errors, tag },
+    } = await this.query(CreateCategoryDocument, {
+      input: {
+        locale,
+        category: {
+          type: categoryType,
+          slug: params.slug,
+          name: params.name,
+          settings: JSON.stringify(params.settings || {}),
+        },
+      },
+    });
+
+    return { tag, errors };
+  }
+
+  async update(id, params, locale, categoryType) {
+    const {
+      updateCategory: { errors, category },
+    } = await this.query(UpdateCategoryDocument, {
+      input: {
+        id,
+        locale,
+        category: {
+          type: categoryType,
+          slug: params.slug,
+          name: params.name,
+          settings: JSON.stringify(params.settings || {}),
+        },
+      },
+    });
+
+    return { category, errors };
+  }
+
+  async delete(id, locale) {
+    const {
+      deleteCategory: { errors, tag },
+    } = await this.query(DeleteCategoryDocumet, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return { tag, errors };
+  }
+}

package/src/cloud/EventChanges.js

@@ -0,0 +1,36 @@
+import RaketaClient from "./RaketaClient";
+import {
+  EventHistoryDocument,
+  EventEditorsDocument,
+} from "./documents/eventsDocuments";
+
+export default class EventChanges extends RaketaClient {
+  async list(query, eventId, locale) {
+    const vars = this.buildListInput(query, locale);
+
+    const { eventHistory: items } = await this.query(EventHistoryDocument, {
+      input: {
+        ...vars.input,
+        id: eventId,
+        locale,
+        pagination: {
+          ...(vars.input.pagination || {}),
+          page_size: 50,
+        },
+      },
+    });
+
+    return items;
+  }
+
+  async all_editors(eventId, locale) {
+    const { eventEditors } = await this.query(EventEditorsDocument, {
+      input: {
+        id: eventId,
+        locale,
+      },
+    });
+
+    return eventEditors?.list;
+  }
+}