@raketa-cloud/admin 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "main": "src/index.js",
   "scripts": {
     "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",

package/src/Adapter.js

@@ -93,19 +93,19 @@ export default class Adapter {
     this.router = router;
   }
 
-  routeCollection(_resource, _mapping) {
+  routeCollection(_resource, _mapping, _handlerOpts) {
     throw new Error("Implement in an adapter");
   }
 
-  routeNestedCollection(_resource, _mapping) {
+  routeNestedCollection(_resource, _mapping, _handlerOpts) {
     throw new Error("Implement in an adapter");
   }
 
-  routeMember(_resource, _mapping) {
+  routeMember(_resource, _mapping, _handlerOpts) {
     throw new Error("Implement in an adapter");
   }
 
-  routeNestedMember(_resource, _mapping) {
+  routeNestedMember(_resource, _mapping, _handlerOpts) {
     throw new Error("Implement in an adapter");
   }
 

package/src/HonoAdapter.js

@@ -72,16 +72,10 @@ export default class HonoAdapter extends Adapter {
     });
   }
 
-  async createAction([
-    verb,
-    path,
-    resource,
-    views,
-    action,
-    handler,
-    before_filter,
-    after_filter,
-  ]) {
+  async createAction(
+    [verb, path, resource, views, action, handler, before_filter, after_filter],
+    handlerOpts
+  ) {
     const method = this.getMethod(verb);
 
     Object.keys(this.globalConfig.i18n.locales).forEach((currentLocale) => {
@@ -153,7 +147,7 @@ export default class HonoAdapter extends Adapter {
           redirect,
           json,
           assigns: actionAssigns = {},
-        } = (await handler(ctx)) || {};
+        } = (await handler(ctx, handlerOpts)) || {};
         assigns.actionAssigns = actionAssigns;
 
         this.applyHeaders(headers, routerCtx);
@@ -200,20 +194,20 @@ export default class HonoAdapter extends Adapter {
     });
   }
 
-  routeCollection(mapping) {
-    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  routeCollection(mapping, handlerOpts) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap, handlerOpts));
   }
 
-  routeNestedCollection(mapping) {
-    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  routeNestedCollection(mapping, handlerOpts) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap, handlerOpts));
   }
 
-  routeMember(mapping) {
-    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  routeMember(mapping, handlerOpts) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap, handlerOpts));
   }
 
-  routeNestedMember(mapping) {
-    mapping.forEach((handlerMap) => this.createAction(handlerMap));
+  routeNestedMember(mapping, handlerOpts) {
+    mapping.forEach((handlerMap) => this.createAction(handlerMap, handlerOpts));
   }
 
   getMethod(verb) {

package/src/cloud/Articles.js

@@ -41,11 +41,15 @@ export default class Articles extends RaketaClient {
     return item;
   }
 
-  async list(query, locale) {
-    const { articles: items } = await this.query(
-      ArticlesDocument,
-      this.buildListInput(query, locale)
-    );
+  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;
   }

package/src/cloud/EventChanges.js

@@ -0,0 +1,15 @@
+import RaketaClient from "./RaketaClient";
+import { EventChangesDocument } from "./documents/eventsDocuments";
+
+export default class EventChanges extends RaketaClient {
+  async all(eventId, locale) {
+    const { eventChanges: items } = await this.query(EventChangesDocument, {
+      input: {
+        id: eventId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+}

package/src/cloud/EventRevisions.js

@@ -0,0 +1,149 @@
+import RaketaClient from "./RaketaClient";
+import {
+  DeleteEventDocument,
+  LockEventRevisionDocument,
+  MergeEventRevisionDocument,
+  EventRevisionDocument,
+  EventRevisionsDocument,
+  StartEventRevisionDocument,
+  UnlockEventRevisionDocument,
+  UpdateEventDocument,
+  UpdateEventWidgetsDocument,
+  ReopenEventChangeDocument,
+} from "./documents/eventsDocuments";
+
+export default class EventRevisions extends RaketaClient {
+  async all(eventId, locale) {
+    const { eventRevisions: items } = await this.query(EventRevisionsDocument, {
+      input: {
+        id: eventId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { eventRevision } = await this.query(EventRevisionDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return eventRevision;
+  }
+
+  async publish(id, locale, params, eventParams) {
+    const {
+      mergeEventRevision: { event, errors },
+    } = await this.query(MergeEventRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        event: { ...eventParams },
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async create(eventId, locale) {
+    const {
+      startEventRevision: { revision, errors, eventErrors },
+    } = await this.query(StartEventRevisionDocument, {
+      input: {
+        id: eventId,
+        locale,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+
+  async update(id, locale, params) {
+    const {
+      updateEvent: { errors, event },
+    } = await this.query(UpdateEventDocument, {
+      input: {
+        id,
+        locale,
+        event: params,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async updateWidgets(id, locale, widgets) {
+    const {
+      updateEventWidgets: { errors, event },
+    } = await this.query(UpdateEventWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async delete(revisionId, locale) {
+    const {
+      deleteEvent: { event, errors },
+    } = await this.query(DeleteEventDocument, {
+      input: {
+        id: revisionId,
+        locale,
+      },
+    });
+
+    return { revision: event, errors };
+  }
+
+  async lock(revisionId, locale, message) {
+    const {
+      lockEventRevision: { revision, errors },
+    } = await this.query(LockEventRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale) {
+    const {
+      unlockEventRevision: { revision, errors },
+    } = await this.query(UnlockEventRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async revert(eventId, version, locale) {
+    const {
+      reopenEventChange: { revision, errors, eventErrors },
+    } = await this.query(ReopenEventChangeDocument, {
+      input: {
+        eventId,
+        locale,
+        version,
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+}

package/src/cloud/Events.js

@@ -0,0 +1,139 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CreateEventDocument,
+  EventByIdDocument,
+  EventsDocument,
+  CloneEventDocument,
+  DeleteEventDocument,
+  TranslateEventDocument,
+  ChangeEventSlugDocument,
+} from "./documents/eventsDocuments";
+import { toDateTimeInput } from "../utils";
+
+export default class Events extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      layout: "default",
+      publish_at: toDateTimeInput(new Date()),
+      starts_at: toDateTimeInput(new Date()),
+      ends_at: toDateTimeInput(new Date()),
+      tags: [],
+      categories: [],
+    };
+  }
+
+  visibilityOptions() {
+    return [
+      ["private", "Private"],
+      ["public", "Public"],
+      ["unlisted", "Unlisted"],
+      ["protected", "Password protected"],
+    ];
+  }
+
+  async find(id, locale) {
+    const { event: item } = await this.query(EventByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async list(query, locale, eventTypeSlug) {
+    const vars = this.buildListInput(query, locale);
+
+    const { events: items } = await this.query(EventsDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, eventTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async create(params, locale, eventTypeSlug) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      createEvent: { errors, event },
+    } = await this.query(CreateEventDocument, {
+      input: {
+        locale,
+        event: params,
+        eventTypeSlug,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async clone(id, locale) {
+    const {
+      cloneEvent: { errors, event },
+    } = await this.query(CloneEventDocument, {
+      input: { id: id, locale: locale },
+    });
+
+    return { event, errors };
+  }
+
+  async delete(id, locale, redirect) {
+    const input = {
+      id,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      deleteEvent: { errors, event },
+    } = await this.query(DeleteEventDocument, { input });
+
+    return { event, errors };
+  }
+
+  async translate(id, locale, params) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      translateEvent: { errors, event },
+    } = await this.query(TranslateEventDocument, {
+      input: {
+        locale,
+        sourceEventId: id,
+        event: params,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async updateSlug(id, slug, locale, redirect) {
+    const input = {
+      id,
+      slug,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      changeEventSlug: { errors, event },
+    } = await this.query(ChangeEventSlugDocument, {
+      input,
+    });
+
+    return { event, errors };
+  }
+}

package/src/cloud/Pages.js

@@ -39,11 +39,15 @@ export default class Pages extends RaketaClient {
     return item;
   }
 
-  async list(query, locale) {
-    const { pages: items } = await this.query(
-      PagesDocument,
-      this.buildListInput(query, locale)
-    );
+  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;
   }

package/src/cloud/documents/common.js

@@ -20,6 +20,16 @@ export function articleTypeFragment() {
   `;
 }
 
+export function eventTypeFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+    }
+  `;
+}
+
 export function tagFragment() {
   return gql`
     {

package/src/cloud/documents/eventsDocuments.js

@@ -0,0 +1,254 @@
+import { gql } from "graphql-request";
+import {
+  categoryFragment,
+  errorsFragment,
+  eventTypeFragment,
+  paginationFragment,
+  revisionMetaFragment,
+  tagFragment,
+} from "./common";
+
+function eventFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      translations
+      revisionsCount
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+function eventRevisionFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      insertedAt
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      meta ${revisionMetaFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+const EventByIdDocument = gql`
+  query EventByID($input: IdInput!) {
+    event(input: $input) ${eventFragment()}
+  }
+`;
+
+const EventChangesDocument = gql`
+  query EventChanges($input: IdInput!) {
+    eventChanges(input: $input) {
+      list {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const EventsDocument = gql`
+  query Events($input: EventsInput!) {
+    events(input: $input) {
+      list ${eventFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const CreateEventDocument = gql`
+  mutation CreateEvent($input: CreateEventInput!) {
+    createEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateEventDocument = gql`
+  mutation UpdateEvent($input: UpdateEventInput!) {
+    updateEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateEventWidgetsDocument = gql`
+  mutation updateEventWidgets($input: UpdateEventWidgetsInput!) {
+    updateEventWidgets(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const CloneEventDocument = gql`
+  mutation CloneEvent($input: IdInput!) {
+    cloneEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeleteEventDocument = gql`
+  mutation DeleteEvent($input: EventDeleteInput!) {
+    deleteEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const EventAndSiteDocument = gql`
+  query EventAndSite($input: SlugInput!) {
+    eventAndSite(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      translations
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      categories ${categoryFragment()}
+      websiteSettings
+    }
+  }
+`;
+
+const TranslateEventDocument = gql`
+  mutation TranslateEvent($input: TranslateEventInput!) {
+    translateEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const EventRevisionsDocument = gql`
+  query EventRevisions($input: IdInput!) {
+    eventRevisions(input: $input) {
+      list ${eventRevisionFragment()}
+    }
+  }
+`;
+
+const EventRevisionDocument = gql`
+  query EventRevision($input: IdInput!) {
+    eventRevision(input: $input) ${eventRevisionFragment()}
+  }
+`;
+
+const StartEventRevisionDocument = gql`
+  mutation StartEventRevision($input: StartEventRevisionInput!) {
+    startEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const MergeEventRevisionDocument = gql`
+  mutation MergeEventRevision($input: MergeEventRevisionInput!) {
+    mergeEventRevision(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ChangeEventSlugDocument = gql`
+  mutation ($input: ChangeEventSlugInput!) {
+    changeEventSlug(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ReopenEventChangeDocument = gql`
+  mutation($input: ReopenEventChangeInput!)
+    {
+      reopenEventChange(input: $input) {
+        revision ${eventRevisionFragment()}
+        errors ${errorsFragment()}
+        eventErrors ${errorsFragment()}
+      }
+    }
+`;
+
+const LockEventRevisionDocument = gql`
+  mutation LockEventRevision($input: LockEventRevisionInput!) {
+    lockEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const UnlockEventRevisionDocument = gql`
+  mutation UnlockEventRevision($input: UnlockEventRevisionInput!) {
+    unlockEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+export {
+  EventByIdDocument,
+  EventsDocument,
+  CreateEventDocument,
+  UpdateEventDocument,
+  UpdateEventWidgetsDocument,
+  CloneEventDocument,
+  DeleteEventDocument,
+  EventAndSiteDocument,
+  TranslateEventDocument,
+  EventRevisionDocument,
+  EventRevisionsDocument,
+  StartEventRevisionDocument,
+  MergeEventRevisionDocument,
+  EventChangesDocument,
+  ChangeEventSlugDocument,
+  ReopenEventChangeDocument,
+  LockEventRevisionDocument,
+  UnlockEventRevisionDocument,
+};