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