Accepting or rejecting mutations for user-teams (#204)

- Fixes search teams
- Mutations to accept/reject teams
- Exposes pronouns as ENUM

Author: fforres

src/authn/index.ts

@@ -8,6 +8,7 @@ import {
   findUserByID,
   updateUserProfileInfo,
 } from "~/datasources/queries/users";
+import { getUsername } from "~/datasources/queries/utils/createUsername";
 import { unauthorizedError } from "~/errors";
 
 // Obtener el token de autorización de la solicitud, ya sea del encabezado de
@@ -129,7 +130,7 @@ export const upsertUserFromRequest = async ({
     imageUrl: avatar_url ? avatar_url : picture ? picture : "",
     externalId: sub,
     name,
-    username: user_name,
+    username: user_name ?? getUsername(),
     publicMetadata: payload,
   });
 

src/datasources/db/teams.ts

@@ -46,3 +46,10 @@ export type TEAM = z.infer<typeof selectTeamsSchema>;
 
 export const selectTeamsSchema = createSelectSchema(teamsSchema);
 export const insertTeamsSchema = createInsertSchema(teamsSchema);
+export const updateTeamsSchema = insertTeamsSchema
+  .pick({
+    name: true,
+    description: true,
+    teamStatus: true,
+  })
+  .partial();

src/datasources/db/userTeams.ts

@@ -56,3 +56,9 @@ export const userTeamsRelations = relations(userTeamsSchema, ({ one }) => ({
 
 export const selectUserTeamsSchema = createSelectSchema(userTeamsSchema);
 export const insertUserTeamsSchema = createInsertSchema(userTeamsSchema);
+export const udpateUserTeamsSchema = insertUserTeamsSchema
+  .pick({
+    discipline: true,
+    userParticipationStatus: true,
+  })
+  .partial();

src/datasources/db/users.ts

@@ -63,3 +63,14 @@ export type USER = z.infer<typeof selectUsersSchema>;
 
 export const selectUsersSchema = createSelectSchema(usersSchema);
 export const insertUsersSchema = createInsertSchema(usersSchema);
+export const updateUsersSchema = insertUsersSchema
+  .pick({
+    name: true,
+    lastName: true,
+    bio: true,
+    pronouns: true,
+    gender: true,
+    genderOtherText: true,
+    username: true,
+  })
+  .partial();

src/schema/teams/mutations.ts

@@ -7,6 +7,8 @@ import {
   insertUserTeamsSchema,
   selectTeamsSchema,
   teamsSchema,
+  udpateUserTeamsSchema,
+  updateTeamsSchema,
   UserParticipationStatusEnum,
   UserTeamRoleEnum,
   userTeamsSchema,
@@ -42,7 +44,7 @@ builder.mutationField("createTeam", (t) =>
       }),
     },
     authz: {
-      rules: ["IsAuthenticated"],
+      rules: ["IsSuperAdmin"],
     },
     resolve: async (root, { input }, { DB, USER }) => {
       if (!USER) {
@@ -130,7 +132,7 @@ builder.mutationField("addPersonToTeam", (t) =>
       }),
     },
     authz: {
-      rules: ["IsAuthenticated"],
+      rules: ["IsSuperAdmin"],
     },
     resolve: async (root, { input }, { USER, DB, logger }) => {
       const { teamId, userEmail } = input;
@@ -227,7 +229,7 @@ builder.mutationField("deletePersonFomTeam", (t) =>
       }),
     },
     authz: {
-      rules: ["IsAuthenticated"],
+      rules: ["IsSuperAdmin"],
     },
     resolve: async (root, { input }, { USER, DB }) => {
       const { teamId, userId } = input;
@@ -257,7 +259,7 @@ builder.mutationField("deletePersonFomTeam", (t) =>
   }),
 );
 
-const updateTeam = builder.inputType("updateTeam", {
+const updateTeam = builder.inputType("UpdateTeamInput", {
   fields: (t) => ({
     teamId: t.string({
       required: true,
@@ -273,7 +275,7 @@ const updateTeam = builder.inputType("updateTeam", {
 
 builder.mutationField("updateTeam", (t) =>
   t.field({
-    description: "Try to add a person to a team",
+    description: "Updates a team information",
     type: TeamRef,
     args: {
       input: t.arg({
@@ -306,13 +308,14 @@ builder.mutationField("updateTeam", (t) =>
       addToObjectIfPropertyExists(properties, "name", name);
       addToObjectIfPropertyExists(properties, "description", description);
 
-      const teamToUpdate = insertTeamsSchema.parse(properties);
+      const teamToUpdate = updateTeamsSchema.parse(properties);
 
-      await DB.update(teamsSchema)
+      const udpatedTeam = await DB.update(teamsSchema)
         .set(teamToUpdate)
-        .where(eq(teamsSchema.id, teamId));
+        .where(eq(teamsSchema.id, teamId))
+        .returning();
 
-      return team;
+      return selectTeamsSchema.parse(udpatedTeam[0]);
     },
   }),
 );
@@ -330,7 +333,7 @@ const acceptTeamInvitationInput = builder.inputType(
 
 builder.mutationField("acceptTeamInvitation", (t) =>
   t.field({
-    description: "Accept an invitation to a team",
+    description: "Accept the user's invitation to a team",
     type: TeamRef,
     args: {
       input: t.arg({
@@ -362,13 +365,71 @@ builder.mutationField("acceptTeamInvitation", (t) =>
         throw new GraphQLError("You do not have permission to edit this team");
       }
 
-      const teamToUpdate = insertTeamsSchema.parse({
+      const teamToUpdate = udpateUserTeamsSchema.parse({
         userParticipationStatus: UserParticipationStatusEnum.accepted,
       });
 
       await DB.update(userTeamsSchema)
         .set(teamToUpdate)
-        .where(eq(userTeamsSchema.teamId, teamId));
+        .where(eq(userTeamsSchema.id, teamAndUsers?.id));
+
+      return team;
+    },
+  }),
+);
+
+const rejectTeamInvitationInput = builder.inputType(
+  "RejectTeamInvitationInput",
+  {
+    fields: (t) => ({
+      teamId: t.string({
+        required: true,
+      }),
+    }),
+  },
+);
+
+builder.mutationField("rejectTeamInvitation", (t) =>
+  t.field({
+    description: "Reject the user's invitation to a team",
+    type: TeamRef,
+    args: {
+      input: t.arg({
+        type: rejectTeamInvitationInput,
+        required: true,
+      }),
+    },
+    authz: {
+      rules: ["IsAuthenticated"],
+    },
+    resolve: async (root, { input }, { USER, DB }) => {
+      const { teamId } = input;
+
+      if (!USER) {
+        throw new GraphQLError("User not found");
+      }
+
+      const teamAndUsers = await DB.query.userTeamsSchema.findFirst({
+        where: (t, { eq, and }) =>
+          and(eq(t.teamId, teamId), eq(t.userId, USER.id)),
+        with: {
+          team: true,
+          user: true,
+        },
+      });
+      const team = teamAndUsers?.team;
+
+      if (!team) {
+        throw new GraphQLError("You do not have permission to edit this team");
+      }
+
+      const teamToUpdate = udpateUserTeamsSchema.parse({
+        userParticipationStatus: UserParticipationStatusEnum.not_accepted,
+      });
+
+      await DB.update(userTeamsSchema)
+        .set(teamToUpdate)
+        .where(eq(userTeamsSchema.id, teamAndUsers?.id));
 
       return team;
     },

src/schema/teams/tests/mutations.test.ts

@@ -19,7 +19,7 @@ import {
 
 describe("Team", () => {
   describe("Should create a team", () => {
-    it("As an admin", async () => {
+    it("As an super admin", async () => {
       const user1 = await insertUser();
       const event = await insertEvent();
 
@@ -28,22 +28,19 @@ describe("Team", () => {
         userId: user1.id,
         role: "admin",
       });
-      const response = await executeGraphqlOperationAsUser<
+      const response = await executeGraphqlOperationAsSuperAdmin<
         CreateTeamMutation,
         CreateTeamMutationVariables
-      >(
-        {
-          document: CreateTeam,
-          variables: {
-            input: {
-              description: faker.lorem.paragraph(3),
-              name: faker.lorem.words(3),
-              eventId: event.id,
-            },
+      >({
+        document: CreateTeam,
+        variables: {
+          input: {
+            description: faker.lorem.paragraph(3),
+            name: faker.lorem.words(3),
+            eventId: event.id,
           },
         },
-        user1,
-      );
+      });
 
       assert.equal(response.errors, undefined);
       const team = await findTeamById(response?.data?.createTeam?.id);
@@ -76,10 +73,12 @@ describe("Team", () => {
   });
   it("Should error on creating a second team", async () => {
     const event = await insertEvent();
-    const user = await insertUser();
+    const user = await insertUser({
+      isSuperAdmin: true,
+    });
 
     // Create the first team
-    await executeGraphqlOperationAsUser<
+    await executeGraphqlOperationAsSuperAdmin<
       CreateTeamMutation,
       CreateTeamMutationVariables
     >(
@@ -97,7 +96,7 @@ describe("Team", () => {
     );
 
     // Attempt to create a second team for the same event
-    const response = await executeGraphqlOperationAsUser<
+    const response = await executeGraphqlOperationAsSuperAdmin<
       CreateTeamMutation,
       CreateTeamMutationVariables
     >(

src/schema/user/mutations.ts

@@ -3,11 +3,14 @@ import { GraphQLError } from "graphql";
 
 import { builder } from "~/builder";
 import {
+  PronounsEnum,
   selectUsersSchema,
+  updateUsersSchema,
   usersSchema,
   usersToCommunitiesSchema,
 } from "~/datasources/db/schema";
 import { UserRef } from "~/schema/shared/refs";
+import { pronounsEnum } from "~/schema/user/types";
 import {
   UserRoleCommunity,
   canUpdateUserRoleInCommunity,
@@ -21,21 +24,12 @@ const userEditInput = builder.inputType("userEditInput", {
     lastName: t.string({ required: false }),
     bio: t.string({ required: false }),
     username: t.string({ required: false }),
+    pronouns: t.field({ type: pronounsEnum, required: false }),
   }),
 });
-const updateUserRoleInCommunityInput = builder.inputType(
-  "updateUserRoleInCommunityInput",
-  {
-    fields: (t) => ({
-      userId: t.string({ required: true }),
-      communityId: t.string({ required: true }),
-      role: t.string({ required: true }),
-    }),
-  },
-);
 
-builder.mutationFields((t) => ({
-  updateUser: t.field({
+builder.mutationField("updateUser", (t) =>
+  t.field({
     description: "Update a user",
     type: UserRef,
     nullable: false,
@@ -47,7 +41,7 @@ builder.mutationFields((t) => ({
     },
     resolve: async (root, { input }, ctx) => {
       try {
-        const { id, name, lastName, bio, username } = input;
+        const { id, name, lastName, bio, username, pronouns } = input;
 
         if (!ctx.USER) {
           throw new Error("User not found");
@@ -62,6 +56,7 @@ builder.mutationFields((t) => ({
           lastName?: string;
           bio?: string;
           username?: string;
+          pronouns?: PronounsEnum;
         };
 
         if (name) {
@@ -80,9 +75,14 @@ builder.mutationFields((t) => ({
           updateFields.username = username;
         }
 
+        if (pronouns) {
+          updateFields.pronouns = pronouns;
+        }
+
+        const userData = updateUsersSchema.parse(updateFields);
         const user = (
           await ctx.DB.update(usersSchema)
-            .set(updateFields)
+            .set(userData)
             .where(eq(usersSchema.id, id))
             .returning()
         )?.[0];
@@ -95,7 +95,21 @@ builder.mutationFields((t) => ({
       }
     },
   }),
-  updateUserRoleInCommunity: t.field({
+);
+
+const updateUserRoleInCommunityInput = builder.inputType(
+  "updateUserRoleInCommunityInput",
+  {
+    fields: (t) => ({
+      userId: t.string({ required: true }),
+      communityId: t.string({ required: true }),
+      role: t.string({ required: true }),
+    }),
+  },
+);
+
+builder.mutationField("updateUserRoleInCommunity", (t) =>
+  t.field({
     description: "Update a user role",
     type: UserRef,
     nullable: false,
@@ -141,4 +155,4 @@ builder.mutationFields((t) => ({
       }
     },
   }),
-}));
+);