@raketa-cloud/admin 1.8.3 → 1.8.6

package/src/cloud/documents/resourcesDocuments.js

@@ -0,0 +1,371 @@
+import { gql } from "graphql-request";
+import {
+  categoryFragment,
+  errorsFragment,
+  paginationFragment,
+  revisionMetaFragment,
+  revisionScheduleFragment,
+  summaryChangeFragment,
+  tagFragment,
+} from "./common";
+
+function minimalResourceFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      resourceType
+      visibility
+      insertedAt
+      updatedAt
+      translations
+    }
+  `;
+}
+
+function resourceFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      resourceType
+      originalId
+      translations
+      revisionsCount
+      insertedAt
+      updatedAt
+      tags ${tagFragment()}
+      categories ${categoryFragment()}
+      changes ${summaryChangeFragment()}
+    }
+  `;
+}
+
+function resourceRevisionFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      resourceType
+      originalId
+      insertedAt
+      updatedAt
+      tags ${tagFragment()}
+      meta ${revisionMetaFragment()}
+      schedule ${revisionScheduleFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+const ResourceByIdDocument = gql`
+  query ResourceByID($input: IdTypeInput!) {
+    resource(input: $input) ${resourceFragment()}
+  }
+`;
+
+const ResourceHistoryDocument = gql`
+  query ResourceHistory($input: ResourceHistoryInput!) {
+    resourceHistory(input: $input) {
+      list ${summaryChangeFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const ResourceEditorsDocument = gql`
+  query ResourceEditors($input: ResourceEditorsInput!) {
+    resourceEditors(input: $input) {
+      list {
+        id
+        name
+      }
+    }
+  }
+`;
+
+const MiniResourcesDocument = gql`
+  query MiniResources($input: ResourcesInput!) {
+    miniResources(input: $input) {
+      list ${minimalResourceFragment()}
+    }
+  }
+`;
+
+const ResourcesDocument = gql`
+  query Resources($input: ResourcesInput!) {
+    resources(input: $input) {
+      list ${resourceFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const CreateResourceDocument = gql`
+  mutation CreateResource($input: CreateResourceInput!) {
+    createResource(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateResourceDocument = gql`
+  mutation UpdateResource($input: UpdateResourceInput!) {
+    updateResource(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateResourceWidgetsDocument = gql`
+  mutation UpdateResourceWidgets($input: UpdateResourceWidgetsInput!) {
+    updateResourceWidgets(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const CloneResourceDocument = gql`
+  mutation CloneResource($input: IdTypeInput!) {
+    cloneResource(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeleteResourceDocument = gql`
+  mutation DeleteResource($input: ResourceDeleteInput!) {
+    deleteResource(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ResourceAndSiteDocument = gql`
+  query ResourceAndSite($input: SlugTypeInput!) {
+    resourceAndSite(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      resourceType
+      originalId
+      translations
+      tags ${tagFragment()}
+      categories ${categoryFragment()}
+      websiteSettings
+    }
+  }
+`;
+
+const TranslateResourceDocument = gql`
+  mutation TranslateResource($input: TranslateResourceInput!) {
+    translateResource(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const buildBatchTranslateResourceDocument = (count) => gql`
+  mutation BatchTranslateResources(${Array(count)
+    .fill(0)
+    .map((_, i) => `$input${i}: TranslateResourceInput!`)
+    .join(", ")}) {
+    ${Array(count)
+      .fill(0)
+      .map(
+        (_, i) => `
+      translate${i}: translateResource(input: $input${i}) {
+        resource ${resourceFragment()}
+        errors ${errorsFragment()}
+      }
+    `,
+      )
+      .join("\n")}
+  }
+`;
+
+const ResourceRevisionsDocument = gql`
+  query ResourceRevisions($input: IdTypeInput!) {
+    resourceRevisions(input: $input) {
+      list ${resourceRevisionFragment()}
+    }
+  }
+`;
+
+const ResourceRevisionDocument = gql`
+  query ResourceRevision($input: IdTypeInput!) {
+    resourceRevision(input: $input) ${resourceRevisionFragment()}
+  }
+`;
+
+const StartResourceRevisionDocument = gql`
+  mutation StartResourceRevision($input: StartResourceRevisionInput!) {
+    startResourceRevision(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const buildBatchStartResourceRevisionDocument = (count) => gql`
+  mutation BatchStartResourceRevisions(${Array(count)
+    .fill(0)
+    .map((_, i) => `$input${i}: StartResourceRevisionInput!`)
+    .join(", ")}) {
+    ${Array(count)
+      .fill(0)
+      .map(
+        (_, i) => `
+      startRevision${i}: startResourceRevision(input: $input${i}) {
+        revision ${resourceRevisionFragment()}
+        errors ${errorsFragment()}
+        resourceErrors ${errorsFragment()}
+      }
+    `,
+      )
+      .join("\n")}
+  }
+`;
+
+const MergeResourceRevisionDocument = gql`
+  mutation MergeResourceRevision($input: MergeResourceRevisionInput!) {
+    mergeResourceRevision(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ScheduleResourceRevisionDocument = gql`
+  mutation ($input: ScheduleResourceRevisionInput!) {
+    scheduleResourceRevision(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const CancelResourceRevisionScheduleDocument = gql`
+  mutation ($input: CancelResourceRevisionScheduleInput!) {
+    cancelResourceRevisionSchedule(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const ChangeResourceSlugDocument = gql`
+  mutation ($input: ChangeResourceSlugInput!) {
+    changeResourceSlug(input: $input) {
+      resource ${resourceFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ReopenResourceChangeDocument = gql`
+  mutation ($input: ReopenResourceChangeInput!) {
+    reopenResourceChange(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const LockResourceRevisionDocument = gql`
+  mutation LockResourceRevision($input: LockResourceRevisionInput!) {
+    lockResourceRevision(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const UnlockResourceRevisionDocument = gql`
+  mutation UnlockResourceRevision($input: UnlockResourceRevisionInput!) {
+    unlockResourceRevision(input: $input) {
+      revision ${resourceRevisionFragment()}
+      errors ${errorsFragment()}
+      resourceErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const ResourceChangePreviewDocument = gql`
+  query ($input: ResourceChangePreviewInput!) {
+    resourceChangePreview(input: $input) {
+      resource {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        resourceType
+        translations
+        tags ${tagFragment()}
+        websiteSettings
+      }
+      resourceChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+export {
+  ResourceByIdDocument,
+  ResourcesDocument,
+  MiniResourcesDocument,
+  CreateResourceDocument,
+  UpdateResourceDocument,
+  UpdateResourceWidgetsDocument,
+  CloneResourceDocument,
+  DeleteResourceDocument,
+  ResourceAndSiteDocument,
+  TranslateResourceDocument,
+  ResourceRevisionDocument,
+  ResourceRevisionsDocument,
+  StartResourceRevisionDocument,
+  MergeResourceRevisionDocument,
+  ScheduleResourceRevisionDocument,
+  CancelResourceRevisionScheduleDocument,
+  ChangeResourceSlugDocument,
+  ReopenResourceChangeDocument,
+  LockResourceRevisionDocument,
+  UnlockResourceRevisionDocument,
+  buildBatchTranslateResourceDocument,
+  ResourceHistoryDocument,
+  buildBatchStartResourceRevisionDocument,
+  ResourceEditorsDocument,
+  ResourceChangePreviewDocument,
+};

package/src/handlers/_shared/getResourceUpdateDestination.js

@@ -0,0 +1,11 @@
+export default function getResourceUpdateDestination(
+  ctx,
+  revision_id,
+  section
+) {
+  const base = `/${ctx.locale}/${ctx.resourceConfig.resourceType}_revisions/${revision_id}/`;
+  const shouldPublish = ctx.body && ctx.body._next === "publish";
+  return shouldPublish
+    ? `${base}publishes/new`
+    : `${base}${section}/edit?success=1`;
+}

package/src/handlers/resource_revisions/CancelSchedulesHandler.js

@@ -0,0 +1,31 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType, resourceTypePlural } = ctx.resourceConfig;
+
+  const { revision, errors, resourceErrors } =
+    await ctx.client.resourceRevisions.cancelSchedule(
+      parent_id,
+      ctx.locale,
+      resourceType,
+    );
+
+  if (errors) {
+    throw new Error(
+      `Failed to cancel schedule for revision: ${JSON.stringify(errors)}`,
+    );
+  }
+
+  if (resourceErrors) {
+    throw new Error(
+      `Failed to cancel schedule for revision: ${JSON.stringify(resourceErrors)}`,
+    );
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${resourceTypePlural}/${revision.originalId}`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/resource_revisions/CodeHandler.js

@@ -0,0 +1,70 @@
+import getResourceUpdateDestination from "../_shared/getResourceUpdateDestination";
+
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const resource = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const revision = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.resource;
+  const resource = ctx.client.resourceRevisions.deepMerge(revision, params);
+
+  const { errors } = await ctx.client.resourceRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.resourceRevisions.selectUpdateParams(resource),
+    resourceType,
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+        errors: {
+          resource: ctx.client.resourceRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: getResourceUpdateDestination(ctx, revision.id, "codes"),
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/resource_revisions/GeneralHandler.js

@@ -0,0 +1,72 @@
+import getResourceUpdateDestination from "../_shared/getResourceUpdateDestination";
+
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const resource = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      visibilityOptions: ctx.client.resources.visibilityOptions(),
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const revision = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.resource;
+  const resource = ctx.client.resourceRevisions.deepMerge(revision, params);
+
+  const { errors } = await ctx.client.resourceRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.resourceRevisions.selectUpdateParams(resource),
+    resourceType,
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+        visibilityOptions: ctx.client.resources.visibilityOptions(),
+        errors: {
+          resource: ctx.client.resourceRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: getResourceUpdateDestination(ctx, revision.id, "general"),
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/{article_revisions → resource_revisions}/LocksHandler.js

@@ -1,9 +1,11 @@
 const create_form = async (ctx) => {
   const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
 
-  const revision = await ctx.client.articleRevisions.find(
+  const revision = await ctx.client.resourceRevisions.find(
     parent_id,
-    ctx.locale
+    ctx.locale,
+    resourceType,
   );
 
   if (!revision) {
@@ -28,20 +30,23 @@ const create_form = async (ctx) => {
 const create = async (ctx) => {
   const { parent_id } = ctx.params;
   const { message } = ctx.resourceParams.resource;
+  const { resourceType, resourceTypePlural } = ctx.resourceConfig;
 
-  const revision = await ctx.client.articleRevisions.find(
+  const revision = await ctx.client.resourceRevisions.find(
     parent_id,
-    ctx.locale
+    ctx.locale,
+    resourceType,
   );
 
   if (!revision) {
     throw new Error(`Missing revision #${parent_id}`);
   }
 
-  const { errors, articleErrors } = await ctx.client.articleRevisions.lock(
+  const { errors, resourceErrors } = await ctx.client.resourceRevisions.lock(
     parent_id,
     ctx.locale,
-    message
+    message,
+    resourceType,
   );
 
   if (errors) {
@@ -53,21 +58,21 @@ const create = async (ctx) => {
           message,
         },
         errors: {
-          resource: ctx.client.articleRevisions.formatErrors(errors, "message"),
+          resource: ctx.client.resourceRevisions.formatErrors(errors, "message"),
         },
         _translations: [],
       },
     };
   }
 
-  if (articleErrors) {
+  if (resourceErrors) {
     throw new Error(
-      `Failed to lock revision: ${JSON.stringify(articleErrors)}`
+      `Failed to lock revision: ${JSON.stringify(resourceErrors)}`,
     );
   }
 
   return {
-    redirect: `/${ctx.locale}/${ctx.resourceConfig.articleTypePlural}/${revision.originalId}`,
+    redirect: `/${ctx.locale}/${resourceTypePlural}/${revision.originalId}`,
   };
 };
 

package/src/handlers/resource_revisions/MetaHandler.js

@@ -0,0 +1,70 @@
+import getResourceUpdateDestination from "../_shared/getResourceUpdateDestination";
+
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const resource = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { resourceType } = ctx.resourceConfig;
+
+  const revision = await ctx.client.resourceRevisions.find(
+    parent_id,
+    ctx.locale,
+    resourceType,
+  );
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.resource;
+  const resource = ctx.client.resourceRevisions.deepMerge(revision, params);
+
+  const { errors } = await ctx.client.resourceRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.resourceRevisions.selectUpdateParams(resource),
+    resourceType,
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+        errors: {
+          resource: ctx.client.resourceRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: getResourceUpdateDestination(ctx, revision.id, "meta"),
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};