@masheev/better-auth 0.0.0-stage → 1.7.5

package/dist/plugins/organization/routes/crud-team.mjs

@@ -0,0 +1,766 @@
+import { setSessionCookie } from "../../../cookies/index.mjs";
+import { toZodSchema } from "../../../db/to-zod.mjs";
+import { getSessionFromCtx } from "../../../api/routes/session.mjs";
+import { ORGANIZATION_ERROR_CODES } from "../error-codes.mjs";
+import { getOrgAdapter } from "../adapter.mjs";
+import { orgMiddleware, orgSessionMiddleware } from "../call.mjs";
+import { hasPermission } from "../has-permission.mjs";
+import { teamSchema } from "../schema.mjs";
+import { getCurrentAdapter, runWithTransaction } from "@better-auth/core/context";
+import { APIError } from "@better-auth/core/error";
+import { createAuthEndpoint } from "@better-auth/core/api";
+import * as z from "zod";
+//#region src/plugins/organization/routes/crud-team.ts
+const teamBaseSchema = z.object({
+	name: z.string().meta({ description: "The name of the team. Eg: \"my-team\"" }),
+	organizationId: z.string().meta({ description: "The organization ID which the team will be created in. Defaults to the active organization. Eg: \"organization-id\"" }).optional()
+});
+const createTeam = (options) => {
+	const additionalFieldsSchema = toZodSchema({
+		fields: options?.schema?.team?.additionalFields ?? {},
+		isClientSide: true
+	});
+	return createAuthEndpoint("/organization/create-team", {
+		method: "POST",
+		body: z.object({
+			...teamBaseSchema.shape,
+			...additionalFieldsSchema.shape
+		}),
+		use: [orgMiddleware],
+		metadata: {
+			$Infer: { body: {} },
+			openapi: {
+				description: "Create a new team within an organization",
+				responses: { "200": {
+					description: "Team created successfully",
+					content: { "application/json": { schema: {
+						type: "object",
+						properties: {
+							id: {
+								type: "string",
+								description: "Unique identifier of the created team"
+							},
+							name: {
+								type: "string",
+								description: "Name of the team"
+							},
+							organizationId: {
+								type: "string",
+								description: "ID of the organization the team belongs to"
+							},
+							createdAt: {
+								type: "string",
+								format: "date-time",
+								description: "Timestamp when the team was created"
+							},
+							updatedAt: {
+								type: "string",
+								format: "date-time",
+								description: "Timestamp when the team was last updated"
+							}
+						},
+						required: [
+							"id",
+							"name",
+							"organizationId",
+							"createdAt",
+							"updatedAt"
+						]
+					} } }
+				} }
+			}
+		}
+	}, async (ctx) => {
+		const session = await getSessionFromCtx(ctx);
+		const organizationId = ctx.body.organizationId || session?.session.activeOrganizationId;
+		if (!session && (ctx.request || ctx.headers)) throw APIError.fromStatus("UNAUTHORIZED");
+		if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+		const adapter = getOrgAdapter(ctx.context, options);
+		if (session) {
+			const member = await adapter.findMemberByOrgId({
+				userId: session.user.id,
+				organizationId
+			});
+			if (!member) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_INVITE_USERS_TO_THIS_ORGANIZATION);
+			if (!await hasPermission({
+				role: member.role,
+				options: ctx.context.orgOptions,
+				permissions: { team: ["create"] },
+				organizationId
+			}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_CREATE_TEAMS_IN_THIS_ORGANIZATION);
+		}
+		const existingTeams = await adapter.listTeams(organizationId);
+		const maximum = typeof ctx.context.orgOptions.teams?.maximumTeams === "function" ? await ctx.context.orgOptions.teams?.maximumTeams({
+			organizationId,
+			session
+		}, ctx) : ctx.context.orgOptions.teams?.maximumTeams;
+		if (maximum ? existingTeams.length >= maximum : false) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.YOU_HAVE_REACHED_THE_MAXIMUM_NUMBER_OF_TEAMS);
+		const { name, organizationId: _, ...additionalFields } = ctx.body;
+		const organization = await adapter.findOrganizationById(organizationId);
+		if (!organization) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+		let teamData = {
+			name,
+			organizationId,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date(),
+			...additionalFields
+		};
+		if (options?.organizationHooks?.beforeCreateTeam) {
+			const response = await options?.organizationHooks.beforeCreateTeam({
+				team: {
+					name,
+					organizationId,
+					...additionalFields
+				},
+				user: session?.user,
+				organization
+			});
+			if (response && typeof response === "object" && "data" in response) teamData = {
+				...teamData,
+				...response.data
+			};
+		}
+		const createdTeam = await adapter.createTeam(teamData);
+		if (options?.organizationHooks?.afterCreateTeam) await options?.organizationHooks.afterCreateTeam({
+			team: createdTeam,
+			user: session?.user,
+			organization
+		});
+		return ctx.json(createdTeam);
+	});
+};
+const removeTeamBodySchema = z.object({
+	teamId: z.string().meta({ description: `The team ID of the team to remove. Eg: "team-id"` }),
+	organizationId: z.string().meta({ description: `The organization ID which the team falls under. If not provided, it will default to the user's active organization. Eg: "organization-id"` }).optional()
+});
+const removeTeam = (options) => createAuthEndpoint("/organization/remove-team", {
+	method: "POST",
+	body: removeTeamBodySchema,
+	use: [orgMiddleware],
+	metadata: { openapi: {
+		description: "Remove a team from an organization",
+		responses: { "200": {
+			description: "Team removed successfully",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: {
+					type: "string",
+					description: "Confirmation message indicating successful removal",
+					enum: ["Team removed successfully."]
+				} },
+				required: ["message"]
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	const session = await getSessionFromCtx(ctx);
+	const organizationId = ctx.body.organizationId || session?.session.activeOrganizationId;
+	if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+	if (!session && (ctx.request || ctx.headers)) throw APIError.fromStatus("UNAUTHORIZED");
+	const adapter = getOrgAdapter(ctx.context, options);
+	if (session) {
+		const member = await adapter.findMemberByOrgId({
+			userId: session.user.id,
+			organizationId
+		});
+		if (!member || session.session?.activeTeamId === ctx.body.teamId) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_DELETE_THIS_TEAM);
+		if (!await hasPermission({
+			role: member.role,
+			options: ctx.context.orgOptions,
+			permissions: { team: ["delete"] },
+			organizationId
+		}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_DELETE_TEAMS_IN_THIS_ORGANIZATION);
+	}
+	const team = await adapter.findTeamById({
+		teamId: ctx.body.teamId,
+		organizationId
+	});
+	if (!team || team.organizationId !== organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+	if (!ctx.context.orgOptions.teams?.allowRemovingAllTeams) {
+		if ((await adapter.listTeams(organizationId)).length <= 1) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.UNABLE_TO_REMOVE_LAST_TEAM);
+	}
+	const organization = await adapter.findOrganizationById(organizationId);
+	if (!organization) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+	if (options?.organizationHooks?.beforeDeleteTeam) await options?.organizationHooks.beforeDeleteTeam({
+		team,
+		user: session?.user,
+		organization
+	});
+	await runWithTransaction(ctx.context.adapter, async () => {
+		await adapter.deleteTeam(team.id);
+		const pendingInvitations = await adapter.findPendingInvitations({ organizationId });
+		const trx = await getCurrentAdapter(ctx.context.adapter);
+		for (const invitation of pendingInvitations) {
+			if (!("teamId" in invitation) || !invitation.teamId) continue;
+			const teamIds = invitation.teamId.split(",");
+			if (!teamIds.includes(team.id)) continue;
+			const remainingTeamIds = teamIds.filter((id) => id !== team.id);
+			await trx.update({
+				model: "invitation",
+				where: [{
+					field: "id",
+					value: invitation.id
+				}],
+				update: { teamId: remainingTeamIds.length > 0 ? remainingTeamIds.join(",") : null }
+			});
+		}
+	});
+	if (options?.organizationHooks?.afterDeleteTeam) await options?.organizationHooks.afterDeleteTeam({
+		team,
+		user: session?.user,
+		organization
+	});
+	return ctx.json({ message: "Team removed successfully." });
+});
+const updateTeam = (options) => {
+	const additionalFieldsSchema = toZodSchema({
+		fields: options?.schema?.team?.additionalFields ?? {},
+		isClientSide: true
+	});
+	return createAuthEndpoint("/organization/update-team", {
+		method: "POST",
+		body: z.object({
+			teamId: z.string().meta({ description: `The ID of the team to be updated. Eg: "team-id"` }),
+			data: z.object({
+				...teamSchema.omit({
+					id: true,
+					createdAt: true,
+					updatedAt: true
+				}).shape,
+				...additionalFieldsSchema.shape
+			}).partial()
+		}),
+		requireHeaders: true,
+		use: [orgMiddleware, orgSessionMiddleware],
+		metadata: {
+			$Infer: { body: {} },
+			openapi: {
+				description: "Update an existing team in an organization",
+				responses: { "200": {
+					description: "Team updated successfully",
+					content: { "application/json": { schema: {
+						type: "object",
+						properties: {
+							id: {
+								type: "string",
+								description: "Unique identifier of the updated team"
+							},
+							name: {
+								type: "string",
+								description: "Updated name of the team"
+							},
+							organizationId: {
+								type: "string",
+								description: "ID of the organization the team belongs to"
+							},
+							createdAt: {
+								type: "string",
+								format: "date-time",
+								description: "Timestamp when the team was created"
+							},
+							updatedAt: {
+								type: "string",
+								format: "date-time",
+								description: "Timestamp when the team was last updated"
+							}
+						},
+						required: [
+							"id",
+							"name",
+							"organizationId",
+							"createdAt",
+							"updatedAt"
+						]
+					} } }
+				} }
+			}
+		}
+	}, async (ctx) => {
+		const session = ctx.context.session;
+		const organizationId = ctx.body.data.organizationId || session.session.activeOrganizationId;
+		if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+		const adapter = getOrgAdapter(ctx.context, options);
+		const member = await adapter.findMemberByOrgId({
+			userId: session.user.id,
+			organizationId
+		});
+		if (!member) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM);
+		if (!await hasPermission({
+			role: member.role,
+			options: ctx.context.orgOptions,
+			permissions: { team: ["update"] },
+			organizationId
+		}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_TEAM);
+		const team = await adapter.findTeamById({
+			teamId: ctx.body.teamId,
+			organizationId
+		});
+		if (!team || team.organizationId !== organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+		const { name, organizationId: __, ...additionalFields } = ctx.body.data;
+		const organization = await adapter.findOrganizationById(organizationId);
+		if (!organization) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+		const updates = {
+			name,
+			...additionalFields
+		};
+		if (options?.organizationHooks?.beforeUpdateTeam) {
+			const response = await options?.organizationHooks.beforeUpdateTeam({
+				team,
+				updates,
+				user: session.user,
+				organization
+			});
+			if (response && typeof response === "object" && "data" in response) {
+				const modifiedUpdates = response.data;
+				const updatedTeam = await adapter.updateTeam(team.id, modifiedUpdates);
+				if (options?.organizationHooks?.afterUpdateTeam) await options?.organizationHooks.afterUpdateTeam({
+					team: updatedTeam,
+					user: session.user,
+					organization
+				});
+				return ctx.json(updatedTeam);
+			}
+		}
+		const updatedTeam = await adapter.updateTeam(team.id, updates);
+		if (options?.organizationHooks?.afterUpdateTeam) await options?.organizationHooks.afterUpdateTeam({
+			team: updatedTeam,
+			user: session.user,
+			organization
+		});
+		return ctx.json(updatedTeam);
+	});
+};
+const listOrganizationTeamsQuerySchema = z.optional(z.object({ organizationId: z.string().meta({ description: `The organization ID which the teams are under to list. Defaults to the users active organization. Eg: "organization-id"` }).optional() }));
+const listOrganizationTeams = (options) => createAuthEndpoint("/organization/list-teams", {
+	method: "GET",
+	query: listOrganizationTeamsQuerySchema,
+	metadata: { openapi: {
+		description: "List all teams in an organization",
+		responses: { "200": {
+			description: "Teams retrieved successfully",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						id: {
+							type: "string",
+							description: "Unique identifier of the team"
+						},
+						name: {
+							type: "string",
+							description: "Name of the team"
+						},
+						organizationId: {
+							type: "string",
+							description: "ID of the organization the team belongs to"
+						},
+						createdAt: {
+							type: "string",
+							format: "date-time",
+							description: "Timestamp when the team was created"
+						},
+						updatedAt: {
+							type: "string",
+							format: "date-time",
+							description: "Timestamp when the team was last updated"
+						}
+					},
+					required: [
+						"id",
+						"name",
+						"organizationId",
+						"createdAt",
+						"updatedAt"
+					]
+				},
+				description: "Array of team objects within the organization"
+			} } }
+		} }
+	} },
+	requireHeaders: true,
+	use: [orgMiddleware, orgSessionMiddleware]
+}, async (ctx) => {
+	const session = ctx.context.session;
+	const organizationId = ctx.query?.organizationId || session?.session.activeOrganizationId;
+	if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+	const adapter = getOrgAdapter(ctx.context, options);
+	if (!await adapter.findMemberByOrgId({
+		userId: session.user.id,
+		organizationId: organizationId || ""
+	})) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_ACCESS_THIS_ORGANIZATION);
+	const teams = await adapter.listTeams(organizationId);
+	return ctx.json(teams);
+});
+const setActiveTeamBodySchema = z.object({ teamId: z.string().meta({ description: "The team id to set as active. It can be null to unset the active team" }).nullable().optional() });
+const setActiveTeam = (options) => createAuthEndpoint("/organization/set-active-team", {
+	method: "POST",
+	body: setActiveTeamBodySchema,
+	requireHeaders: true,
+	use: [orgSessionMiddleware, orgMiddleware],
+	metadata: { openapi: {
+		description: "Set the active team for the current active organization",
+		responses: { "200": {
+			description: "Success",
+			content: { "application/json": { schema: {
+				type: "object",
+				description: "The team",
+				$ref: "#/components/schemas/Team"
+			} } }
+		} }
+	} }
+}, async (ctx) => {
+	const adapter = getOrgAdapter(ctx.context, ctx.context.orgOptions);
+	const session = ctx.context.session;
+	if (ctx.body.teamId === null) {
+		if (!session.session.activeTeamId) return ctx.json(null);
+		await setSessionCookie(ctx, {
+			session: await adapter.setActiveTeam(session.session.token, null, ctx),
+			user: session.user
+		});
+		return ctx.json(null);
+	}
+	let teamId;
+	if (!ctx.body.teamId) {
+		const sessionTeamId = session.session.activeTeamId;
+		if (!sessionTeamId) return ctx.json(null);
+		else teamId = sessionTeamId;
+	} else teamId = ctx.body.teamId;
+	const activeOrganizationId = session.session.activeOrganizationId;
+	if (!activeOrganizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+	const team = await adapter.findTeamById({
+		teamId,
+		organizationId: activeOrganizationId
+	});
+	if (!team) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+	if (!await adapter.findTeamMember({
+		teamId,
+		userId: session.user.id
+	})) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_TEAM);
+	await setSessionCookie(ctx, {
+		session: await adapter.setActiveTeam(session.session.token, team.id, ctx),
+		user: session.user
+	});
+	return ctx.json(team);
+});
+const listUserTeams = (options) => createAuthEndpoint("/organization/list-user-teams", {
+	method: "GET",
+	query: z.object({
+		userId: z.string().optional().meta({ description: "The user ID to list teams for. Defaults to the current session user." }),
+		organizationId: z.string().optional().meta({ description: "The organization ID to scope the team list to. When omitted on a self-query, teams are returned across every organization the user belongs to. When querying another user, falls back to the session's active organization and is required if there is no active organization." })
+	}).optional(),
+	metadata: { openapi: {
+		description: "List teams for a user. Without parameters, returns teams for the current user across every organization they belong to. Pass `organizationId` to scope the result to a specific organization. Pass `userId` to list teams for another member; this requires `member:update` permission in the target organization (the explicit `organizationId` if provided, otherwise the session's active organization).",
+		responses: { "200": {
+			description: "Teams retrieved successfully",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: {
+					type: "object",
+					description: "The team",
+					$ref: "#/components/schemas/Team"
+				},
+				description: "Array of team objects within the organization"
+			} } }
+		} }
+	} },
+	requireHeaders: true,
+	use: [orgMiddleware, orgSessionMiddleware]
+}, async (ctx) => {
+	const session = ctx.context.session;
+	const adapter = getOrgAdapter(ctx.context, ctx.context.orgOptions);
+	const targetUserId = ctx.query?.userId || session.user.id;
+	const isSelf = targetUserId === session.user.id;
+	const organizationId = ctx.query?.organizationId || session.session.activeOrganizationId;
+	const isExplicitOrg = Boolean(ctx.query?.organizationId);
+	if (!isSelf) {
+		if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+		const requesterMember = await adapter.findMemberByOrgId({
+			userId: session.user.id,
+			organizationId
+		});
+		if (!requesterMember) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION);
+		if (!await hasPermission({
+			role: requesterMember.role,
+			options: ctx.context.orgOptions,
+			permissions: { member: ["update"] },
+			organizationId
+		}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_UPDATE_THIS_MEMBER);
+		if (!await adapter.findMemberByOrgId({
+			userId: targetUserId,
+			organizationId
+		})) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+		const teams = await adapter.listTeamsByUser({ userId: targetUserId });
+		return ctx.json(teams.filter((t) => t.organizationId === organizationId));
+	}
+	if (isExplicitOrg && organizationId) {
+		if (!await adapter.findMemberByOrgId({
+			userId: session.user.id,
+			organizationId
+		})) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_A_MEMBER_OF_THIS_ORGANIZATION);
+		const teams = await adapter.listTeamsByUser({ userId: session.user.id });
+		return ctx.json(teams.filter((t) => t.organizationId === organizationId));
+	}
+	const teams = await adapter.listTeamsByUser({ userId: session.user.id });
+	const orgIds = [...new Set(teams.map((team) => team.organizationId))];
+	const memberships = await Promise.all(orgIds.map((organizationId) => adapter.checkMembership({
+		userId: session.user.id,
+		organizationId
+	})));
+	const memberOrgIds = new Set(orgIds.filter((_, index) => memberships[index]));
+	return ctx.json(teams.filter((team) => memberOrgIds.has(team.organizationId)));
+});
+const listTeamMembersQuerySchema = z.optional(z.object({ teamId: z.string().optional().meta({ description: "The team whose members we should return. If this is not provided the members of the current active team get returned." }) }));
+const listTeamMembers = (options) => createAuthEndpoint("/organization/list-team-members", {
+	method: "GET",
+	query: listTeamMembersQuerySchema,
+	metadata: { openapi: {
+		description: "List the members of the given team.",
+		responses: { "200": {
+			description: "Teams retrieved successfully",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: {
+					type: "object",
+					description: "The team member",
+					properties: {
+						id: {
+							type: "string",
+							description: "Unique identifier of the team member"
+						},
+						userId: {
+							type: "string",
+							description: "The user ID of the team member"
+						},
+						teamId: {
+							type: "string",
+							description: "The team ID of the team the team member is in"
+						},
+						createdAt: {
+							type: "string",
+							format: "date-time",
+							description: "Timestamp when the team member was created"
+						}
+					},
+					required: [
+						"id",
+						"userId",
+						"teamId",
+						"createdAt"
+					]
+				},
+				description: "Array of team member objects within the team"
+			} } }
+		} }
+	} },
+	requireHeaders: true,
+	use: [orgMiddleware, orgSessionMiddleware]
+}, async (ctx) => {
+	const session = ctx.context.session;
+	const adapter = getOrgAdapter(ctx.context, ctx.context.orgOptions);
+	const teamId = ctx.query?.teamId || session?.session.activeTeamId;
+	if (!teamId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.YOU_DO_NOT_HAVE_AN_ACTIVE_TEAM);
+	const team = await adapter.findTeamById({ teamId });
+	if (!team) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+	if (!await adapter.checkMembership({
+		userId: session.user.id,
+		organizationId: team.organizationId
+	})) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_TEAM);
+	if (!await adapter.findTeamMember({
+		userId: session.user.id,
+		teamId
+	})) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_TEAM);
+	const members = await adapter.listTeamMembers({ teamId });
+	return ctx.json(members);
+});
+const addTeamMemberBodySchema = z.object({
+	teamId: z.string().meta({ description: "The team the user should be a member of." }),
+	userId: z.coerce.string().meta({ description: "The user Id which represents the user to be added as a member." }),
+	organizationId: z.string().meta({ description: "The organization ID which the team falls under. If not provided, it will default to the user's active organization." }).optional()
+});
+const addTeamMember = (options) => createAuthEndpoint("/organization/add-team-member", {
+	method: "POST",
+	body: addTeamMemberBodySchema,
+	metadata: { openapi: {
+		description: "The newly created member",
+		responses: { "200": {
+			description: "Team member created successfully",
+			content: { "application/json": { schema: {
+				type: "object",
+				description: "The team member",
+				properties: {
+					id: {
+						type: "string",
+						description: "Unique identifier of the team member"
+					},
+					userId: {
+						type: "string",
+						description: "The user ID of the team member"
+					},
+					teamId: {
+						type: "string",
+						description: "The team ID of the team the team member is in"
+					},
+					createdAt: {
+						type: "string",
+						format: "date-time",
+						description: "Timestamp when the team member was created"
+					}
+				},
+				required: [
+					"id",
+					"userId",
+					"teamId",
+					"createdAt"
+				]
+			} } }
+		} }
+	} },
+	requireHeaders: true,
+	use: [orgMiddleware, orgSessionMiddleware]
+}, async (ctx) => {
+	const session = ctx.context.session;
+	const adapter = getOrgAdapter(ctx.context, ctx.context.orgOptions);
+	const organizationId = ctx.body.organizationId || session.session.activeOrganizationId;
+	if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+	const currentMember = await adapter.findMemberByOrgId({
+		userId: session.user.id,
+		organizationId
+	});
+	if (!currentMember) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+	if (!await hasPermission({
+		role: currentMember.role,
+		options: ctx.context.orgOptions,
+		permissions: { member: ["update"] },
+		organizationId
+	}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_CREATE_A_NEW_TEAM_MEMBER);
+	if (!await adapter.findMemberByOrgId({
+		userId: ctx.body.userId,
+		organizationId
+	})) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+	const team = await adapter.findTeamById({
+		teamId: ctx.body.teamId,
+		organizationId
+	});
+	if (!team) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+	const organization = await adapter.findOrganizationById(organizationId);
+	if (!organization) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+	const userBeingAdded = await ctx.context.internalAdapter.findUserById(ctx.body.userId);
+	if (!userBeingAdded) throw APIError.fromStatus("BAD_REQUEST", { message: "User not found" });
+	if (options?.organizationHooks?.beforeAddTeamMember) {
+		const response = await options?.organizationHooks.beforeAddTeamMember({
+			teamMember: {
+				teamId: ctx.body.teamId,
+				userId: ctx.body.userId
+			},
+			team,
+			user: userBeingAdded,
+			organization
+		});
+		if (response && typeof response === "object" && "data" in response) {}
+	}
+	let teamMember;
+	if (typeof ctx.context.orgOptions.teams?.maximumMembersPerTeam !== "undefined") {
+		const maximumMembersPerTeam = typeof ctx.context.orgOptions.teams.maximumMembersPerTeam === "function" ? await ctx.context.orgOptions.teams.maximumMembersPerTeam({
+			teamId: ctx.body.teamId,
+			session,
+			organizationId
+		}) : ctx.context.orgOptions.teams.maximumMembersPerTeam;
+		const result = await adapter.addTeamMemberWithLimit({
+			teamId: ctx.body.teamId,
+			userId: ctx.body.userId,
+			maximumMembersPerTeam
+		});
+		if (result.status === "limitReached") throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.TEAM_MEMBER_LIMIT_REACHED);
+		teamMember = result.member;
+	} else teamMember = await adapter.findOrCreateTeamMember({
+		teamId: ctx.body.teamId,
+		userId: ctx.body.userId
+	});
+	if (options?.organizationHooks?.afterAddTeamMember) await options?.organizationHooks.afterAddTeamMember({
+		teamMember,
+		team,
+		user: userBeingAdded,
+		organization
+	});
+	return ctx.json(teamMember);
+});
+const removeTeamMemberBodySchema = z.object({
+	teamId: z.string().meta({ description: "The team the user should be removed from." }),
+	userId: z.coerce.string().meta({ description: "The user which should be removed from the team." }),
+	organizationId: z.string().meta({ description: "The organization ID which the team falls under. If not provided, it will default to the user's active organization." }).optional()
+});
+const removeTeamMember = (options) => createAuthEndpoint("/organization/remove-team-member", {
+	method: "POST",
+	body: removeTeamMemberBodySchema,
+	metadata: { openapi: {
+		description: "Remove a member from a team",
+		responses: { "200": {
+			description: "Team member removed successfully",
+			content: { "application/json": { schema: {
+				type: "object",
+				properties: { message: {
+					type: "string",
+					description: "Confirmation message indicating successful removal",
+					enum: ["Team member removed successfully."]
+				} },
+				required: ["message"]
+			} } }
+		} }
+	} },
+	requireHeaders: true,
+	use: [orgMiddleware, orgSessionMiddleware]
+}, async (ctx) => {
+	const session = ctx.context.session;
+	const adapter = getOrgAdapter(ctx.context, ctx.context.orgOptions);
+	const organizationId = ctx.body.organizationId || session.session.activeOrganizationId;
+	if (!organizationId) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.NO_ACTIVE_ORGANIZATION);
+	const currentMember = await adapter.findMemberByOrgId({
+		userId: session.user.id,
+		organizationId
+	});
+	if (!currentMember) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+	if (!await hasPermission({
+		role: currentMember.role,
+		options: ctx.context.orgOptions,
+		permissions: { member: ["delete"] },
+		organizationId
+	}, ctx)) throw APIError.from("FORBIDDEN", ORGANIZATION_ERROR_CODES.YOU_ARE_NOT_ALLOWED_TO_REMOVE_A_TEAM_MEMBER);
+	if (!await adapter.findMemberByOrgId({
+		userId: ctx.body.userId,
+		organizationId
+	})) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_ORGANIZATION);
+	const team = await adapter.findTeamById({
+		teamId: ctx.body.teamId,
+		organizationId
+	});
+	if (!team) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.TEAM_NOT_FOUND);
+	const organization = await adapter.findOrganizationById(organizationId);
+	if (!organization) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.ORGANIZATION_NOT_FOUND);
+	const userBeingRemoved = await ctx.context.internalAdapter.findUserById(ctx.body.userId);
+	if (!userBeingRemoved) throw APIError.fromStatus("BAD_REQUEST", { message: "User not found" });
+	const teamMember = await adapter.findTeamMember({
+		teamId: ctx.body.teamId,
+		userId: ctx.body.userId
+	});
+	if (!teamMember) throw APIError.from("BAD_REQUEST", ORGANIZATION_ERROR_CODES.USER_IS_NOT_A_MEMBER_OF_THE_TEAM);
+	if (options?.organizationHooks?.beforeRemoveTeamMember) await options?.organizationHooks.beforeRemoveTeamMember({
+		teamMember,
+		team,
+		user: userBeingRemoved,
+		organization
+	});
+	await adapter.removeTeamMember({
+		teamId: ctx.body.teamId,
+		userId: ctx.body.userId
+	});
+	if (options?.organizationHooks?.afterRemoveTeamMember) await options?.organizationHooks.afterRemoveTeamMember({
+		teamMember,
+		team,
+		user: userBeingRemoved,
+		organization
+	});
+	return ctx.json({ message: "Team member removed successfully." });
+});
+//#endregion
+export { addTeamMember, createTeam, listOrganizationTeams, listTeamMembers, listUserTeams, removeTeam, removeTeamMember, setActiveTeam, updateTeam };