Added mutations for action Item Category

schema.graphql

@@ -511,6 +511,12 @@ type Community {
   youtubeURL: String
 }
 
+input CreateActionItemCategoryInput {
+  isDisabled: Boolean
+  name: String!
+  organizationId: ID!
+}
+
 input CreateActionItemInput {
   assignedAt: String
   assigneeId: ID!
@@ -773,6 +779,11 @@ type GetUrlResponse {
   presignedUrl: String
 }
 
+type HasUserVoted {
+  """Type of the post vote"""
+  type: PostVoteType!
+}
+
 """
 Possible variants of the two-letter language code defined in ISO 639-1, part of the ISO 639 standard published by the International Organization for Standardization (ISO), to represent natural languages.
 """
@@ -1472,6 +1483,9 @@ type Mutation {
   """Mutation field to create an action item."""
   createActionItem(input: CreateActionItemInput!): ActionItem
 
+  """Mutation field to create a new Action Item Category."""
+  createActionItemCategory(input: CreateActionItemCategoryInput!): ActionItemCategory
+
   """Mutation field to create an advertisement."""
   createAdvertisement(input: MutationCreateAdvertisementInput!): Advertisement
 
@@ -1646,6 +1660,9 @@ type Mutation {
     input: MutationUpdateActionItemInput!
   ): ActionItem
 
+  """Mutation field to update an existing Action Item Category."""
+  updateActionItemCategory(input: UpdateActionItemCategoryInput!): ActionItemCategory
+
   """Mutation field to update an advertisement."""
   updateAdvertisement(input: MutationUpdateAdvertisementInput!): Advertisement
 
@@ -3360,7 +3377,7 @@ type Query {
   fundCampaignPledge(input: QueryFundCampaignPledgeInput!): FundCampaignPledge
 
   """Query field to read a post vote."""
-  hasUserVoted(input: QueryHasUserVotedInput!): hasUserVoted
+  hasUserVoted(input: QueryHasUserVotedInput!): HasUserVoted
 
   """Query field to read an organization."""
   organization(input: QueryOrganizationInput!): Organization
@@ -3666,6 +3683,12 @@ type TagFolderTagsConnectionEdge {
   node: Tag
 }
 
+input UpdateActionItemCategoryInput {
+  categoryId: ID!
+  isDisabled: Boolean
+  name: String
+}
+
 """The `Upload` scalar type represents a file upload."""
 scalar Upload
 
@@ -3894,9 +3917,4 @@ type VenueEventsConnection {
 type VenueEventsConnectionEdge {
   cursor: String!
   node: Event
-}
-
-type hasUserVoted {
-  """Type of the post vote"""
-  type: PostVoteType!
 }

src/graphql/types/Mutation/createActionItemCategory.ts

@@ -0,0 +1,125 @@
+import { sql } from "drizzle-orm";
+import { uuidv7 } from "uuidv7";
+import { z } from "zod";
+import { actionCategoriesTable } from "~/src/drizzle/tables/actionCategories";
+import { builder } from "~/src/graphql/builder";
+import { TalawaGraphQLError } from "~/src/utilities/TalawaGraphQLError";
+
+// 1. Define your ActionItemCategory GraphQL output type (example)
+import { ActionItemCategory } from "../ActionItemCategory/ActionItemCategory";
+
+// 2. Create Zod schema for input validation
+const mutationCreateActionItemCategoryArgumentsSchema = z.object({
+	input: z.object({
+		name: z.string().min(1, "Category name cannot be empty"),
+		organizationId: z.string().uuid(),
+		// Optional fields like isDisabled, if you allow it to be set:
+		isDisabled: z.boolean().optional(),
+	}),
+});
+
+builder.mutationField("createActionItemCategory", (t) =>
+	t.field({
+		type: ActionItemCategory, // The return type
+		args: {
+			input: t.arg({
+				required: true,
+				type: builder.inputType("CreateActionItemCategoryInput", {
+					fields: (t) => ({
+						name: t.field({ type: "String", required: true }),
+						organizationId: t.field({ type: "ID", required: true }),
+						isDisabled: t.field({ type: "Boolean" }), // Allow setting isDisabled from input
+					}),
+				}),
+			}),
+		},
+		description: "Mutation field to create a new Action Item Category.",
+		resolve: async (_parent, args, ctx) => {
+			// 4. Check authentication
+			if (!ctx.currentClient.isAuthenticated) {
+				throw new TalawaGraphQLError({
+					extensions: { code: "unauthenticated" },
+				});
+			}
+
+			// 5. Validate input with Zod
+			const parsedArgs =
+				mutationCreateActionItemCategoryArgumentsSchema.parse(args);
+			const currentUserId = ctx.currentClient.user.id;
+
+			// 6. Check if the organization exists
+			const existingOrganization =
+				await ctx.drizzleClient.query.organizationsTable.findFirst({
+					columns: { id: true },
+					where: (fields, operators) =>
+						operators.eq(fields.id, parsedArgs.input.organizationId),
+				});
+
+			if (!existingOrganization) {
+				throw new TalawaGraphQLError({
+					extensions: {
+						code: "arguments_associated_resources_not_found",
+						issues: [{ argumentPath: ["input", "organizationId"] }],
+					},
+				});
+			}
+
+			// 7. Check if the user is part of the organization
+			const userMembership =
+				await ctx.drizzleClient.query.organizationMembershipsTable.findFirst({
+					columns: { role: true },
+					where: (fields, operators) =>
+						sql`${operators.eq(fields.memberId, currentUserId)} 
+                 AND ${operators.eq(fields.organizationId, parsedArgs.input.organizationId)}`,
+				});
+
+			if (!userMembership) {
+				throw new TalawaGraphQLError({
+					extensions: {
+						code: "unauthorized_action_on_arguments_associated_resources",
+						issues: [{ argumentPath: ["input", "organizationId"] }],
+					},
+				});
+			}
+
+			// 8. Check if the user is an admin (similar logic as action item creation)
+			if (userMembership.role !== "administrator") {
+				throw new TalawaGraphQLError({
+					extensions: {
+						code: "forbidden_action_on_arguments_associated_resources",
+						issues: [
+							{
+								argumentPath: ["input", "organizationId"],
+								message:
+									"Only administrators can create categories for this organization.",
+							},
+						],
+					},
+				});
+			}
+
+			// 9. Insert the new category
+			const [createdCategory] = await ctx.drizzleClient
+				.insert(actionCategoriesTable)
+				.values({
+					id: uuidv7(),
+					name: parsedArgs.input.name,
+					organizationId: parsedArgs.input.organizationId,
+					creatorId: currentUserId,
+					isDisabled: parsedArgs.input.isDisabled ?? false,
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				})
+				.returning();
+
+			if (!createdCategory) {
+				ctx.log.error(
+					"Postgres insert operation unexpectedly returned an empty array.",
+				);
+				throw new TalawaGraphQLError({ extensions: { code: "unexpected" } });
+			}
+
+			return createdCategory;
+		},
+	}),
+);

src/graphql/types/Mutation/index.ts

@@ -77,3 +77,5 @@ import "./createPresignedUrl";
 import "./deleteActionItem";
 import "./updateActionItem";
 import "./createActionItem";
+import "./createActionItemCategory";
+import "./updateActionItemCategory";

src/graphql/types/Mutation/updateActionItemCategory.ts

@@ -0,0 +1,116 @@
+import { eq, sql } from "drizzle-orm";
+import { z } from "zod";
+import { actionCategoriesTable } from "~/src/drizzle/tables/actionCategories";
+import { builder } from "~/src/graphql/builder";
+import { TalawaGraphQLError } from "~/src/utilities/TalawaGraphQLError";
+import { ActionItemCategory } from "../ActionItemCategory/ActionItemCategory";
+
+const mutationUpdateActionItemCategoryArgumentsSchema = z.object({
+	input: z.object({
+		categoryId: z.string().uuid(), // The ID of the category to update
+		name: z.string().optional(), // New name
+		isDisabled: z.boolean().optional(), // Enable/disable
+	}),
+});
+
+builder.mutationField("updateActionItemCategory", (t) =>
+	t.field({
+		type: ActionItemCategory,
+		args: {
+			input: t.arg({
+				required: true,
+				type: builder.inputType("UpdateActionItemCategoryInput", {
+					fields: (t) => ({
+						categoryId: t.field({ type: "ID", required: true }),
+						name: t.field({ type: "String" }),
+						isDisabled: t.field({ type: "Boolean" }),
+					}),
+				}),
+			}),
+		},
+		description: "Mutation field to update an existing Action Item Category.",
+		resolve: async (_parent, args, ctx) => {
+			// 1. Check user authentication
+			if (!ctx.currentClient.isAuthenticated) {
+				throw new TalawaGraphQLError({
+					extensions: { code: "unauthenticated" },
+				});
+			}
+
+			// 2. Validate input
+			const parsedArgs =
+				mutationUpdateActionItemCategoryArgumentsSchema.parse(args);
+			const { categoryId, name, isDisabled } = parsedArgs.input;
+			const currentUserId = ctx.currentClient.user.id;
+
+			// 3. Find the existing category
+			const existingCategory =
+				await ctx.drizzleClient.query.actionCategoriesTable.findFirst({
+					columns: {
+						id: true,
+						organizationId: true,
+					},
+					where: (fields, operators) => operators.eq(fields.id, categoryId),
+				});
+
+			if (!existingCategory) {
+				throw new TalawaGraphQLError({
+					extensions: {
+						code: "arguments_associated_resources_not_found",
+						issues: [{ argumentPath: ["input", "categoryId"] }],
+					},
+				});
+			}
+
+			// 4. Check if the user is an admin in that category's organization
+			const userMembership =
+				await ctx.drizzleClient.query.organizationMembershipsTable.findFirst({
+					columns: { role: true },
+					where: (fields, operators) =>
+						sql`${operators.eq(fields.memberId, currentUserId)}
+                 AND ${operators.eq(fields.organizationId, existingCategory.organizationId)}`,
+				});
+
+			if (!userMembership || userMembership.role !== "administrator") {
+				throw new TalawaGraphQLError({
+					extensions: {
+						code: "forbidden_action_on_arguments_associated_resources",
+						issues: [
+							{
+								argumentPath: ["input", "categoryId"],
+								message: "Only administrators can update this category.",
+							},
+						],
+					},
+				});
+			}
+
+			// 5. Update the category
+			// Build a "set" object only with provided fields
+			const updates: Record<string, unknown> = { updatedAt: new Date() };
+			if (typeof name === "string") {
+				updates.name = name;
+			}
+			if (typeof isDisabled === "boolean") {
+				updates.isDisabled = isDisabled;
+			}
+
+			// ...
+
+			const [updatedCategory] = await ctx.drizzleClient
+				.update(actionCategoriesTable)
+				.set(updates)
+				.where(eq(actionCategoriesTable.id, categoryId))
+				.returning();
+
+			if (!updatedCategory) {
+				ctx.log.error(
+					"Postgres update operation unexpectedly returned an empty array.",
+				);
+				throw new TalawaGraphQLError({ extensions: { code: "unexpected" } });
+			}
+
+			return updatedCategory;
+		},
+	}),
+);