@raketa-cloud/admin 1.8.4 → 1.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "1.8.4",
+  "version": "1.8.7",
   "main": "src/index.js",
   "files": [
     "src/",

package/src/cloud/ResourceChanges.js

@@ -0,0 +1,41 @@
+import RaketaClient from "./RaketaClient";
+import {
+  ResourceEditorsDocument,
+  ResourceHistoryDocument,
+} from "./documents/resourcesDocuments";
+
+export default class ResourceChanges extends RaketaClient {
+  async list(query, resourceId, locale, resourceType) {
+    const vars = this.buildListInput(query, locale);
+
+    const { resourceHistory: items } = await this.query(
+      ResourceHistoryDocument,
+      {
+        input: {
+          ...vars.input,
+          id: resourceId,
+          locale,
+          resourceType,
+          pagination: {
+            ...(vars.input.pagination || {}),
+            page_size: 50,
+          },
+        },
+      }
+    );
+
+    return items;
+  }
+
+  async all_editors(resourceId, locale, resourceType) {
+    const { resourceEditors } = await this.query(ResourceEditorsDocument, {
+      input: {
+        id: resourceId,
+        locale,
+        resourceType,
+      },
+    });
+
+    return resourceEditors?.list;
+  }
+}

package/src/cloud/ResourceRevisions.js

@@ -0,0 +1,242 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CancelResourceRevisionScheduleDocument,
+  DeleteResourceDocument,
+  LockResourceRevisionDocument,
+  MergeResourceRevisionDocument,
+  ReopenResourceChangeDocument,
+  ResourceRevisionDocument,
+  ResourceRevisionsDocument,
+  ScheduleResourceRevisionDocument,
+  StartResourceRevisionDocument,
+  UnlockResourceRevisionDocument,
+  UpdateResourceDocument,
+  UpdateResourceWidgetsDocument,
+  buildBatchStartResourceRevisionDocument,
+} from "./documents/resourcesDocuments";
+
+export default class ResourceRevisions extends RaketaClient {
+  selectUpdateParams(revision) {
+    return {
+      title: revision.title,
+      slug: revision.slug,
+      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)),
+    };
+  }
+
+  async all(resourceId, locale, resourceType) {
+    const { resourceRevisions: items } = await this.query(
+      ResourceRevisionsDocument,
+      {
+        input: {
+          id: resourceId,
+          locale,
+          resourceType,
+        },
+      }
+    );
+
+    return items;
+  }
+
+  async find(id, locale, resourceType) {
+    const { resourceRevision } = await this.query(ResourceRevisionDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+      },
+    });
+
+    return resourceRevision;
+  }
+
+  async publish(id, locale, params, resourceParams, resourceType) {
+    const {
+      mergeResourceRevision: { resource, errors },
+    } = await this.query(MergeResourceRevisionDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+        ...params,
+        resource: { ...resourceParams, resourceType },
+      },
+    });
+
+    return { resource, errors };
+  }
+
+  async schedule(id, locale, params, resourceParams, resourceType) {
+    const {
+      scheduleResourceRevision: { revision, errors, resourceErrors },
+    } = await this.query(ScheduleResourceRevisionDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+        ...params,
+        resource: { ...resourceParams, resourceType },
+      },
+    });
+
+    return { revision, errors, resourceErrors };
+  }
+
+  async cancelSchedule(id, locale, resourceType) {
+    const {
+      cancelResourceRevisionSchedule: { revision, errors, resourceErrors },
+    } = await this.query(CancelResourceRevisionScheduleDocument, {
+      input: {
+        revisionId: id,
+        locale,
+        resourceType,
+      },
+    });
+
+    return { revision, errors, resourceErrors };
+  }
+
+  async create(resourceId, locale, resourceType) {
+    const {
+      startResourceRevision: { revision, errors, resourceErrors },
+    } = await this.query(StartResourceRevisionDocument, {
+      input: {
+        id: resourceId,
+        locale,
+        resourceType,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, resourceErrors };
+  }
+
+  async createBatch(revisionInputs) {
+    const BatchStartRevisionDocument = buildBatchStartResourceRevisionDocument(
+      revisionInputs.length
+    );
+
+    const variables = {};
+    revisionInputs.forEach((input, i) => {
+      variables[`input${i}`] = {
+        id: input.resourceId,
+        locale: input.locale,
+        resourceType: input.resourceType,
+        title: "New revision",
+        description: "",
+      };
+    });
+
+    const response = await this.query(BatchStartRevisionDocument, variables);
+
+    return revisionInputs.map((_, i) => {
+      const result = response[`startRevision${i}`];
+      return {
+        revision: result.revision,
+        errors: result.errors,
+        resourceErrors: result.resourceErrors,
+      };
+    });
+  }
+
+  async update(id, locale, params, resourceType) {
+    const copyParams = { ...params, resourceType };
+
+    copyParams.widgets = JSON.stringify(params.widgets || []);
+    copyParams.settings = JSON.stringify(params.settings || {});
+
+    const {
+      updateResource: { errors, resource },
+    } = await this.query(UpdateResourceDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+        resource: copyParams,
+      },
+    });
+
+    return { resource, errors };
+  }
+
+  async updateWidgets(id, locale, widgets, resourceType) {
+    const {
+      updateResourceWidgets: { errors, resource },
+    } = await this.query(UpdateResourceWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { resource, errors };
+  }
+
+  async delete(revisionId, locale, resourceType) {
+    const {
+      deleteResource: { resource, errors },
+    } = await this.query(DeleteResourceDocument, {
+      input: {
+        id: revisionId,
+        locale,
+        resourceType,
+      },
+    });
+
+    return { revision: resource, errors };
+  }
+
+  async lock(revisionId, locale, message, resourceType) {
+    const {
+      lockResourceRevision: { revision, errors },
+    } = await this.query(LockResourceRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+        resourceType,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale, resourceType) {
+    const {
+      unlockResourceRevision: { revision, errors },
+    } = await this.query(UnlockResourceRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+        resourceType,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async revert(resourceId, version, locale, resourceType) {
+    const {
+      reopenResourceChange: { revision, errors, resourceErrors },
+    } = await this.query(ReopenResourceChangeDocument, {
+      input: {
+        resourceId,
+        locale,
+        resourceType,
+        version,
+      },
+    });
+
+    return { revision, errors, resourceErrors };
+  }
+}

package/src/cloud/Resources.js

@@ -0,0 +1,219 @@
+import { toDateInput, toDateTimeInput } from "../utils";
+import RaketaClient from "./RaketaClient";
+import {
+  ChangeResourceSlugDocument,
+  CloneResourceDocument,
+  CreateResourceDocument,
+  DeleteResourceDocument,
+  MiniResourcesDocument,
+  ResourceByIdDocument,
+  ResourceChangePreviewDocument,
+  ResourcesDocument,
+  TranslateResourceDocument,
+  buildBatchTranslateResourceDocument,
+} from "./documents/resourcesDocuments";
+
+const SETTINGS_DATE_DEFAULTS = {
+  publish_at: () => toDateInput(new Date()),
+  starts_at: () => toDateTimeInput(),
+  ends_at: () => toDateTimeInput(),
+};
+
+export default class Resources extends RaketaClient {
+  defaults(dateFields = []) {
+    const settings = { layout: "default" };
+
+    for (const field of dateFields) {
+      const provide = SETTINGS_DATE_DEFAULTS[field];
+      if (provide) settings[field] = provide();
+    }
+
+    return {
+      visibility: "private",
+      tags: [],
+      categories: [],
+      widgets: [],
+      settings,
+    };
+  }
+
+  visibilityOptions() {
+    return [
+      ["private", "Private"],
+      ["public", "Public"],
+      ["unlisted", "Unlisted"],
+      ["protected", "Password protected"],
+    ];
+  }
+
+  async find(id, locale, resourceType) {
+    const { resource: item } = await this.query(ResourceByIdDocument, {
+      input: {
+        id,
+        locale,
+        resourceType,
+      },
+    });
+
+    return item;
+  }
+
+  async listAll(query, locale, resourceType) {
+    const vars = this.buildAllInput(query, locale);
+
+    vars.input.filters = this.formatDateFilters(vars.input.filters);
+
+    const { miniResources: items } = await this.query(MiniResourcesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, resourceType },
+      },
+    });
+
+    return items;
+  }
+
+  async list(query, locale, resourceType) {
+    const vars = this.buildListInput(query, locale);
+
+    vars.input.filters = this.formatDateFilters(vars.input.filters);
+
+    const { resources: items } = await this.query(ResourcesDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, resourceType },
+      },
+    });
+
+    return items;
+  }
+
+  async create(params, locale, resourceType) {
+    const paramsCopy = { ...params, resourceType };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      createResource: { errors, resource },
+    } = await this.query(CreateResourceDocument, {
+      input: {
+        locale,
+        resource: paramsCopy,
+      },
+    });
+
+    return { resource, errors };
+  }
+
+  async clone(id, locale, resourceType) {
+    const {
+      cloneResource: { errors, resource },
+    } = await this.query(CloneResourceDocument, {
+      input: { id, locale, resourceType },
+    });
+
+    return { resource, errors };
+  }
+
+  async delete(id, locale, resourceType, redirect) {
+    const input = {
+      id,
+      locale,
+      resourceType,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      deleteResource: { errors, resource },
+    } = await this.query(DeleteResourceDocument, { input });
+
+    return { resource, errors };
+  }
+
+  async translate(id, locale, params, resourceType) {
+    const paramsCopy = { ...params, resourceType };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      translateResource: { errors, resource },
+    } = await this.query(TranslateResourceDocument, {
+      input: {
+        locale,
+        sourceResourceId: id,
+        resource: paramsCopy,
+      },
+    });
+
+    return { resource, errors };
+  }
+
+  async translateBatch(sourceResourceId, locales, params, resourceType) {
+    const paramsCopy = { ...params, resourceType };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const BatchTranslateDocument = buildBatchTranslateResourceDocument(
+      locales.length
+    );
+
+    const variables = {};
+    locales.forEach((locale, i) => {
+      variables[`input${i}`] = {
+        locale,
+        sourceResourceId,
+        resource: paramsCopy,
+      };
+    });
+
+    const response = await this.query(BatchTranslateDocument, variables);
+
+    return locales.map((_, i) => {
+      const result = response[`translate${i}`];
+      return {
+        resource: result.resource,
+        errors: result.errors,
+      };
+    });
+  }
+
+  async updateSlug(id, slug, locale, resourceType, redirect) {
+    const input = {
+      id,
+      slug,
+      locale,
+      resourceType,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      changeResourceSlug: { errors, resource },
+    } = await this.query(ChangeResourceSlugDocument, {
+      input,
+    });
+
+    return { resource, errors };
+  }
+
+  async getChangePreview(resourceId, version, locale, resourceType) {
+    const input = {
+      resourceId,
+      resourceType,
+      version: Number.parseInt(version, 10),
+      locale,
+    };
+
+    const { resourceChangePreview } = await this.query(
+      ResourceChangePreviewDocument,
+      { input }
+    );
+
+    return resourceChangePreview;
+  }
+}

package/src/cloud/documents/common.js

@@ -1,35 +1,5 @@
 import { gql } from "graphql-request";
 
-export function pageTypeFragment() {
-  return gql`
-    {
-      id
-      slug
-      title
-    }
-  `;
-}
-
-export function articleTypeFragment() {
-  return gql`
-    {
-      id
-      slug
-      title
-    }
-  `;
-}
-
-export function eventTypeFragment() {
-  return gql`
-    {
-      id
-      slug
-      title
-    }
-  `;
-}
-
 export function tagFragment() {
   return gql`
     {