1const updateEventExtension = ({ nexus, strapi }) => ({
  2  types: [
  3    nexus.extendType({
  4      type: "Event",
  5      definition(t) {
  6        t.field("waitingPassengers", {
  7          type: "PassengerRelationResponseCollection",
  8        });
  9      },
 10    }),
 11    nexus.extendType({
 12      type: "Query",
 13      definition(t) {
 14        t.field("eventByUUID", {
 15          type: "EventEntityResponse",
 16          args: {
 17            uuid: nexus.nonNull("String"),
 18          },
 19        });
 20      },
 21    }),
 22    nexus.extendType({
 23      type: "Mutation",
 24      definition(t) {
 25        t.field("updateEventByUUID", {
 26          type: "EventEntityResponse",
 27          args: {
 28            uuid: nexus.nonNull("String"),
 29            data: nexus.nonNull("EventInput"),
 30          },
 31        });
 32      },
 33    }),
 34  ],
 35  resolvers: {
 36    Event: {
 37      waitingPassengers: async (root, args) => {
 38        const waitingPassengers = await strapi
 39          .service("api::event.event")
 40          .getWaitingPassengers(root);
 41        const { toEntityResponseCollection } = strapi
 42          .plugin("graphql")
 43          .service("format").returnTypes;
 44        return toEntityResponseCollection(waitingPassengers, {
 45          args,
 46          resourceUID: "api::passenger.passenger",
 47        });
 48      },
 49    },
 50    Query: {
 51      eventByUUID: {
 52        description: "Retrieve an event using its UUID",
 53        async resolve(_root, args) {
 54          const { uuid } = args;
 55          const event = await strapi.db
 56            .query("api::event.event")
 57            .findOne({ where: { uuid } });
 58          if (!event) throw new Error("No matching event");
 59          const { toEntityResponse } = strapi
 60            .plugin("graphql")
 61            .service("format").returnTypes;
 62          return toEntityResponse(event, {
 63            args,
 64            resourceUID: "api::event.event",
 65          });
 66        },
 67      },
 68    },
 69    Mutation: {
 70      updateEventByUUID: {
 71        description: "Update an event using its UUID",
 72        async resolve(_root, args) {
 73          const { uuid, data: eventUpdate } = args;
 74
 75          const updatedEvent = await strapi.db
 76            .query("api::event.event")
 77            .update({ where: { uuid }, data: eventUpdate });
 78          if (!updatedEvent) throw new Error("No matching event");
 79
 80          const { toEntityResponse } = strapi
 81            .plugin("graphql")
 82            .service("format").returnTypes;
 83          return toEntityResponse(updatedEvent, {
 84            args,
 85            resourceUID: "api::event.event",
 86          });
 87        },
 88      },
 89      createEvent: {
 90        async resolve(_root, args, context) {
 91          const {
 92            koaContext,
 93            state: { user },
 94          } = context;
 95
 96          let eventData = args.data;
 97          if (user) eventData = { ...eventData, users: [user.id] };
 98
 99          koaContext.request.body = eventData;
100
101          const createdEvent = await strapi
102            .controller("api::event.event")
103            .create(koaContext);
104
105          return {
106            value: createdEvent,
107            info: { args, resourceUID: "api::event.event" },
108          };
109        },
110      },
111    },
112  },
113  resolversConfig: {
114    "Query.eventByUUID": {
115      auth: {
116        scope: ["api::event.event.findOne"],
117      },
118    },
119    "Mutation.updateEventByUUID": {
120      auth: {
121        scope: ["api::event.event.update"],
122      },
123    },
124  },
125});
126
127export default [updateEventExtension];