@robelest/convex-auth 0.0.4-preview.2 → 0.0.4-preview.21

package/dist/component/public/groups/members.d.ts

@@ -0,0 +1,204 @@
+declare namespace members_d_exports {
+  export { memberAdd, memberGet, memberGetByGroupAndUser, memberList, memberRemove, memberResolve, memberUpdate };
+}
+/**
+ * Add a user as a member of a group.
+ *
+ * The `roleIds` field stores application-defined role identifiers. The auth
+ * component stores assignments but does not enforce access control — your
+ * application defines what each role means.
+ *
+ * Throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` when the user is
+ * already a member of the target group. The duplicate check uses the
+ * `group_id_user_id` compound index for an exact match.
+ *
+ * @param args.groupId - The `Id<"Group">` of the group to add the user to.
+ * @param args.userId - The `Id<"User">` of the user to add as a member.
+ * @param args.roleIds - Optional array of application-defined role identifiers (e.g. `["admin", "editor"]`).
+ * @param args.status - Optional membership status string (e.g. `"active"`, `"suspended"`). Defaults to whatever your application convention is.
+ * @param args.extend - Optional arbitrary payload for application-specific metadata on the membership.
+ * @returns The `Id<"GroupMember">` of the newly created member document.
+ * @throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` if the user is already a member of this group.
+ *
+ * @example
+ * ```ts
+ * const memberId = await ctx.runMutation(
+ *   components.auth.groups.memberAdd,
+ *   {
+ *     groupId: teamGroupId,
+ *     userId: newUserId,
+ *     roleIds: ["viewer"],
+ *     status: "active",
+ *   },
+ * );
+ * ```
+ */
+declare const memberAdd: any;
+/**
+ * Retrieve a member record by its document ID.
+ *
+ * Performs a direct lookup in the `GroupMember` table and returns the full
+ * member document, or `null` if no member exists with the given ID.
+ *
+ * @param args.memberId - The `Id<"GroupMember">` of the member record to retrieve.
+ * @returns The member document (including `groupId`, `userId`, `roleIds`, `status`, etc.) or `null` if not found.
+ *
+ * @example
+ * ```ts
+ * const member = await ctx.runQuery(components.auth.groups.memberGet, {
+ *   memberId: existingMemberId,
+ * });
+ * if (member !== null) {
+ *   console.log(member.userId, member.roleIds);
+ * }
+ * ```
+ */
+declare const memberGet: any;
+/**
+ * List members with optional filtering, sorting, and pagination.
+ *
+ * Returns `{ items, nextCursor }`. Supports filtering by `groupId`,
+ * `userId`, `roleId`, and `status`. The query engine automatically selects
+ * the best compound index based on the combination of filter fields
+ * provided. The `roleId` filter is applied in-memory after the index scan
+ * because role IDs are stored as an array.
+ *
+ * @param args.where - Optional filter criteria for narrowing results.
+ * @param args.where.groupId - Match members belonging to this group.
+ * @param args.where.userId - Match members for this specific user.
+ * @param args.where.roleId - Match members whose `roleIds` array includes this role identifier.
+ * @param args.where.status - Match members with this exact status string (e.g. `"active"`).
+ * @param args.limit - Maximum number of items per page (clamped to 1..100, defaults to 50).
+ * @param args.cursor - An opaque cursor string from a previous response's `nextCursor` to fetch the next page, or `null` to start from the beginning.
+ * @param args.orderBy - The field to sort by: `"_creationTime"` or `"status"`.
+ * @param args.order - Sort direction: `"asc"` or `"desc"` (defaults to `"desc"`).
+ * @returns An object `{ items, nextCursor }` where `items` is an array of member documents and `nextCursor` is `null` when there are no more pages.
+ *
+ * @example
+ * ```ts
+ * const { items, nextCursor } = await ctx.runQuery(
+ *   components.auth.groups.memberList,
+ *   {
+ *     where: { groupId: teamGroupId, status: "active" },
+ *     limit: 30,
+ *     order: "asc",
+ *   },
+ * );
+ * ```
+ */
+declare const memberList: any;
+/**
+ * Look up a specific user's membership in a specific group.
+ *
+ * Uses the `group_id_user_id` compound index for an efficient exact-match
+ * lookup. Returns `null` if the user is not a member of the group. Unlike
+ * {@link memberResolve}, this does **not** walk the group hierarchy — it
+ * checks only the specified group.
+ *
+ * @param args.groupId - The `Id<"Group">` of the group to check.
+ * @param args.userId - The `Id<"User">` of the user whose membership to look up.
+ * @returns The member document or `null` if the user is not a direct member of the group.
+ *
+ * @example
+ * ```ts
+ * const member = await ctx.runQuery(
+ *   components.auth.groups.memberGetByGroupAndUser,
+ *   { groupId: teamGroupId, userId: currentUserId },
+ * );
+ * if (member !== null) {
+ *   console.log("User has roles:", member.roleIds);
+ * }
+ * ```
+ */
+declare const memberGetByGroupAndUser: any;
+/**
+ * Resolve a user's membership by walking the group hierarchy from the
+ * requested group up to the root. Returns the first matching membership
+ * found, enabling inherited (ancestor-level) access checks.
+ *
+ * The traversal walks from `groupId` to its `parentGroupId`, then to the
+ * parent's parent, and so on, up to `maxDepth` levels (default 32). It
+ * stops at the first group where the user has a membership record. Cycle
+ * detection prevents infinite loops if the hierarchy is malformed.
+ *
+ * When `ancestry` is `true`, the response includes a `traversedGroupIds`
+ * array showing the full path that was walked (useful for debugging or
+ * audit trails).
+ *
+ * This runs entirely inside the component (no cross-component RPCs per level).
+ *
+ * @param args.userId - The `Id<"User">` of the user whose membership to resolve.
+ * @param args.groupId - The `Id<"Group">` to start the upward traversal from.
+ * @param args.maxDepth - Optional maximum number of parent levels to traverse (defaults to 32). Set to `0` to check only the exact group.
+ * @param args.ancestry - When `true`, the response includes the `traversedGroupIds` array showing all group IDs visited during the walk.
+ * @returns An object with:
+ *   - `membership` — the member document at the matched group, or `null` if none was found.
+ *   - `matchedGroupId` — the ID of the group where membership was found, or `null`.
+ *   - `depth` — how many levels above `groupId` the match was found (0 = direct), or `null` if not found.
+ *   - `isDirect` — `true` when `depth === 0`.
+ *   - `isInherited` — `true` when `depth > 0`.
+ *   - `traversedGroupIds` — (only when `ancestry` is `true`) array of group IDs visited.
+ *
+ * @example
+ * ```ts
+ * const result = await ctx.runQuery(
+ *   components.auth.groups.memberResolve,
+ *   {
+ *     userId: currentUserId,
+ *     groupId: subTeamGroupId,
+ *     maxDepth: 5,
+ *     ancestry: true,
+ *   },
+ * );
+ * if (result.membership !== null) {
+ *   console.log(
+ *     result.isDirect ? "Direct member" : `Inherited from depth ${result.depth}`,
+ *   );
+ * }
+ * ```
+ */
+declare const memberResolve: any;
+/**
+ * Remove a member from a group by permanently deleting the member record.
+ *
+ * This is a hard delete — the `GroupMember` document is removed from the
+ * database entirely. If you need soft-delete semantics, use
+ * {@link memberUpdate} to set the `status` field instead.
+ *
+ * @param args.memberId - The `Id<"GroupMember">` of the member record to delete.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(components.auth.groups.memberRemove, {
+ *   memberId: memberToRemoveId,
+ * });
+ * ```
+ */
+declare const memberRemove: any;
+/**
+ * Update a member record's mutable fields such as `roleIds`, `status`, and
+ * `extend`.
+ *
+ * Uses `db.patch` under the hood, so only the fields present in `data` are
+ * modified — all other fields on the member document are left unchanged.
+ *
+ * @param args.memberId - The `Id<"GroupMember">` of the member record to update.
+ * @param args.data - A partial object of fields to patch. Supported keys include `roleIds`, `status`, and `extend`.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * await ctx.runMutation(components.auth.groups.memberUpdate, {
+ *   memberId: existingMemberId,
+ *   data: {
+ *     roleIds: ["admin", "editor"],
+ *     status: "active",
+ *   },
+ * });
+ * ```
+ */
+declare const memberUpdate: any;
+//#endregion
+export { memberAdd, memberGet, memberGetByGroupAndUser, memberList, memberRemove, memberResolve, memberUpdate, members_d_exports };
+//# sourceMappingURL=members.d.ts.map

package/dist/component/public/groups/members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.d.ts","names":[],"sources":["../../../../src/component/public/groups/members.ts"],"mappings":";;;;;;;;;;;;;;;AAqCA;;;;;AAgDA;;;;;AAwCA;;;;;AAqGA;;;;;cA7La,SAAA;;;;;AAyUb;;;;;AA+BA;;;;;;;;;;cAxTa,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;cAqGA,uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2DA,aAAA;;;;;;;;;;;;;;;;;;cAiFA,YAAA;;;;;;;;;;;;;;;;;;;;;;;cA+BA,YAAA"}

package/dist/component/public/groups/members.js

@@ -0,0 +1,355 @@
+import { mutation, query } from "../../functions.js";
+import { vGroupMemberDoc, vPaginated } from "../../model.js";
+import { ConvexError, v } from "convex/values";
+
+//#region src/component/public/groups/members.ts
+/**
+* Add a user as a member of a group.
+*
+* The `roleIds` field stores application-defined role identifiers. The auth
+* component stores assignments but does not enforce access control — your
+* application defines what each role means.
+*
+* Throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` when the user is
+* already a member of the target group. The duplicate check uses the
+* `group_id_user_id` compound index for an exact match.
+*
+* @param args.groupId - The `Id<"Group">` of the group to add the user to.
+* @param args.userId - The `Id<"User">` of the user to add as a member.
+* @param args.roleIds - Optional array of application-defined role identifiers (e.g. `["admin", "editor"]`).
+* @param args.status - Optional membership status string (e.g. `"active"`, `"suspended"`). Defaults to whatever your application convention is.
+* @param args.extend - Optional arbitrary payload for application-specific metadata on the membership.
+* @returns The `Id<"GroupMember">` of the newly created member document.
+* @throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` if the user is already a member of this group.
+*
+* @example
+* ```ts
+* const memberId = await ctx.runMutation(
+*   components.auth.groups.memberAdd,
+*   {
+*     groupId: teamGroupId,
+*     userId: newUserId,
+*     roleIds: ["viewer"],
+*     status: "active",
+*   },
+* );
+* ```
+*/
+const memberAdd = mutation({
+	args: {
+		groupId: v.id("Group"),
+		userId: v.id("User"),
+		roleIds: v.optional(v.array(v.string())),
+		status: v.optional(v.string()),
+		extend: v.optional(v.any())
+	},
+	returns: v.id("GroupMember"),
+	handler: async (ctx, args) => {
+		const existingMembership = await ctx.db.query("GroupMember").withIndex("group_id_user_id", (q) => q.eq("groupId", args.groupId).eq("userId", args.userId)).unique();
+		if (existingMembership !== null) throw new ConvexError({
+			code: "DUPLICATE_MEMBERSHIP",
+			message: "User is already a member of this group",
+			groupId: args.groupId,
+			userId: args.userId,
+			existingMemberId: existingMembership._id
+		});
+		return await ctx.db.insert("GroupMember", args);
+	}
+});
+/**
+* Retrieve a member record by its document ID.
+*
+* Performs a direct lookup in the `GroupMember` table and returns the full
+* member document, or `null` if no member exists with the given ID.
+*
+* @param args.memberId - The `Id<"GroupMember">` of the member record to retrieve.
+* @returns The member document (including `groupId`, `userId`, `roleIds`, `status`, etc.) or `null` if not found.
+*
+* @example
+* ```ts
+* const member = await ctx.runQuery(components.auth.groups.memberGet, {
+*   memberId: existingMemberId,
+* });
+* if (member !== null) {
+*   console.log(member.userId, member.roleIds);
+* }
+* ```
+*/
+const memberGet = query({
+	args: { memberId: v.id("GroupMember") },
+	returns: v.union(vGroupMemberDoc, v.null()),
+	handler: async (ctx, { memberId }) => {
+		return await ctx.db.get("GroupMember", memberId);
+	}
+});
+/**
+* List members with optional filtering, sorting, and pagination.
+*
+* Returns `{ items, nextCursor }`. Supports filtering by `groupId`,
+* `userId`, `roleId`, and `status`. The query engine automatically selects
+* the best compound index based on the combination of filter fields
+* provided. The `roleId` filter is applied in-memory after the index scan
+* because role IDs are stored as an array.
+*
+* @param args.where - Optional filter criteria for narrowing results.
+* @param args.where.groupId - Match members belonging to this group.
+* @param args.where.userId - Match members for this specific user.
+* @param args.where.roleId - Match members whose `roleIds` array includes this role identifier.
+* @param args.where.status - Match members with this exact status string (e.g. `"active"`).
+* @param args.limit - Maximum number of items per page (clamped to 1..100, defaults to 50).
+* @param args.cursor - An opaque cursor string from a previous response's `nextCursor` to fetch the next page, or `null` to start from the beginning.
+* @param args.orderBy - The field to sort by: `"_creationTime"` or `"status"`.
+* @param args.order - Sort direction: `"asc"` or `"desc"` (defaults to `"desc"`).
+* @returns An object `{ items, nextCursor }` where `items` is an array of member documents and `nextCursor` is `null` when there are no more pages.
+*
+* @example
+* ```ts
+* const { items, nextCursor } = await ctx.runQuery(
+*   components.auth.groups.memberList,
+*   {
+*     where: { groupId: teamGroupId, status: "active" },
+*     limit: 30,
+*     order: "asc",
+*   },
+* );
+* ```
+*/
+const memberList = query({
+	args: {
+		where: v.optional(v.object({
+			groupId: v.optional(v.id("Group")),
+			userId: v.optional(v.id("User")),
+			roleId: v.optional(v.string()),
+			status: v.optional(v.string())
+		})),
+		limit: v.optional(v.number()),
+		cursor: v.optional(v.union(v.string(), v.null())),
+		orderBy: v.optional(v.union(v.literal("_creationTime"), v.literal("status"))),
+		order: v.optional(v.union(v.literal("asc"), v.literal("desc")))
+	},
+	returns: vPaginated(vGroupMemberDoc),
+	handler: async (ctx, args) => {
+		const where = args.where ?? {};
+		const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);
+		const order = args.order ?? "desc";
+		let q;
+		if (where.groupId !== void 0 && where.userId !== void 0) {
+			q = ctx.db.query("GroupMember").withIndex("group_id_user_id", (idx) => idx.eq("groupId", where.groupId).eq("userId", where.userId));
+			if (where.status !== void 0) q = q.filter((f) => f.eq(f.field("status"), where.status));
+		} else if (where.groupId !== void 0 && where.status !== void 0) q = ctx.db.query("GroupMember").withIndex("group_id_status", (idx) => idx.eq("groupId", where.groupId).eq("status", where.status));
+		else if (where.groupId !== void 0) q = ctx.db.query("GroupMember").withIndex("group_id", (idx) => idx.eq("groupId", where.groupId));
+		else if (where.userId !== void 0) {
+			q = ctx.db.query("GroupMember").withIndex("user_id", (idx) => idx.eq("userId", where.userId));
+			if (where.status !== void 0) q = q.filter((f) => f.eq(f.field("status"), where.status));
+		} else {
+			q = ctx.db.query("GroupMember");
+			if (where.status !== void 0) q = q.filter((f) => f.eq(f.field("status"), where.status));
+		}
+		q = q.order(order);
+		let all = await q.collect();
+		if (where.roleId !== void 0) all = all.filter((doc) => (doc.roleIds ?? []).includes(where.roleId));
+		let startIdx = 0;
+		if (args.cursor) {
+			const cursorIdx = all.findIndex((doc) => doc._id === args.cursor);
+			if (cursorIdx !== -1) startIdx = cursorIdx + 1;
+		}
+		const page = all.slice(startIdx, startIdx + limit + 1);
+		const hasMore = page.length > limit;
+		const items = hasMore ? page.slice(0, limit) : page;
+		return {
+			items,
+			nextCursor: hasMore ? items[items.length - 1]._id : null
+		};
+	}
+});
+/**
+* Look up a specific user's membership in a specific group.
+*
+* Uses the `group_id_user_id` compound index for an efficient exact-match
+* lookup. Returns `null` if the user is not a member of the group. Unlike
+* {@link memberResolve}, this does **not** walk the group hierarchy — it
+* checks only the specified group.
+*
+* @param args.groupId - The `Id<"Group">` of the group to check.
+* @param args.userId - The `Id<"User">` of the user whose membership to look up.
+* @returns The member document or `null` if the user is not a direct member of the group.
+*
+* @example
+* ```ts
+* const member = await ctx.runQuery(
+*   components.auth.groups.memberGetByGroupAndUser,
+*   { groupId: teamGroupId, userId: currentUserId },
+* );
+* if (member !== null) {
+*   console.log("User has roles:", member.roleIds);
+* }
+* ```
+*/
+const memberGetByGroupAndUser = query({
+	args: {
+		groupId: v.id("Group"),
+		userId: v.id("User")
+	},
+	returns: v.union(vGroupMemberDoc, v.null()),
+	handler: async (ctx, { groupId, userId }) => {
+		return await ctx.db.query("GroupMember").withIndex("group_id_user_id", (q) => q.eq("groupId", groupId).eq("userId", userId)).unique();
+	}
+});
+/**
+* Resolve a user's membership by walking the group hierarchy from the
+* requested group up to the root. Returns the first matching membership
+* found, enabling inherited (ancestor-level) access checks.
+*
+* The traversal walks from `groupId` to its `parentGroupId`, then to the
+* parent's parent, and so on, up to `maxDepth` levels (default 32). It
+* stops at the first group where the user has a membership record. Cycle
+* detection prevents infinite loops if the hierarchy is malformed.
+*
+* When `ancestry` is `true`, the response includes a `traversedGroupIds`
+* array showing the full path that was walked (useful for debugging or
+* audit trails).
+*
+* This runs entirely inside the component (no cross-component RPCs per level).
+*
+* @param args.userId - The `Id<"User">` of the user whose membership to resolve.
+* @param args.groupId - The `Id<"Group">` to start the upward traversal from.
+* @param args.maxDepth - Optional maximum number of parent levels to traverse (defaults to 32). Set to `0` to check only the exact group.
+* @param args.ancestry - When `true`, the response includes the `traversedGroupIds` array showing all group IDs visited during the walk.
+* @returns An object with:
+*   - `membership` — the member document at the matched group, or `null` if none was found.
+*   - `matchedGroupId` — the ID of the group where membership was found, or `null`.
+*   - `depth` — how many levels above `groupId` the match was found (0 = direct), or `null` if not found.
+*   - `isDirect` — `true` when `depth === 0`.
+*   - `isInherited` — `true` when `depth > 0`.
+*   - `traversedGroupIds` — (only when `ancestry` is `true`) array of group IDs visited.
+*
+* @example
+* ```ts
+* const result = await ctx.runQuery(
+*   components.auth.groups.memberResolve,
+*   {
+*     userId: currentUserId,
+*     groupId: subTeamGroupId,
+*     maxDepth: 5,
+*     ancestry: true,
+*   },
+* );
+* if (result.membership !== null) {
+*   console.log(
+*     result.isDirect ? "Direct member" : `Inherited from depth ${result.depth}`,
+*   );
+* }
+* ```
+*/
+const memberResolve = query({
+	args: {
+		userId: v.id("User"),
+		groupId: v.id("Group"),
+		maxDepth: v.optional(v.number()),
+		ancestry: v.optional(v.boolean())
+	},
+	returns: v.object({
+		membership: v.union(vGroupMemberDoc, v.null()),
+		matchedGroupId: v.union(v.id("Group"), v.null()),
+		depth: v.union(v.number(), v.null()),
+		isDirect: v.boolean(),
+		isInherited: v.boolean(),
+		traversedGroupIds: v.optional(v.array(v.id("Group")))
+	}),
+	handler: async (ctx, args) => {
+		const maxDepth = Math.max(0, Math.floor(args.maxDepth ?? 32));
+		const includeAncestry = args.ancestry ?? false;
+		const visited = /* @__PURE__ */ new Set();
+		const traversedGroupIds = [];
+		let currentGroupId = args.groupId;
+		let depth = 0;
+		while (currentGroupId !== void 0 && depth <= maxDepth) {
+			if (visited.has(currentGroupId)) break;
+			visited.add(currentGroupId);
+			if (includeAncestry) traversedGroupIds.push(currentGroupId);
+			const membership = await ctx.db.query("GroupMember").withIndex("group_id_user_id", (q) => q.eq("groupId", currentGroupId).eq("userId", args.userId)).unique();
+			if (membership !== null) return {
+				membership,
+				matchedGroupId: currentGroupId,
+				depth,
+				isDirect: depth === 0,
+				isInherited: depth > 0,
+				...includeAncestry ? { traversedGroupIds } : {}
+			};
+			const groupDoc = await ctx.db.get(currentGroupId);
+			if (!groupDoc?.parentGroupId) break;
+			currentGroupId = groupDoc.parentGroupId;
+			depth++;
+		}
+		return {
+			membership: null,
+			matchedGroupId: null,
+			depth: null,
+			isDirect: false,
+			isInherited: false,
+			...includeAncestry ? { traversedGroupIds } : {}
+		};
+	}
+});
+/**
+* Remove a member from a group by permanently deleting the member record.
+*
+* This is a hard delete — the `GroupMember` document is removed from the
+* database entirely. If you need soft-delete semantics, use
+* {@link memberUpdate} to set the `status` field instead.
+*
+* @param args.memberId - The `Id<"GroupMember">` of the member record to delete.
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* await ctx.runMutation(components.auth.groups.memberRemove, {
+*   memberId: memberToRemoveId,
+* });
+* ```
+*/
+const memberRemove = mutation({
+	args: { memberId: v.id("GroupMember") },
+	returns: v.null(),
+	handler: async (ctx, { memberId }) => {
+		await ctx.db.delete("GroupMember", memberId);
+		return null;
+	}
+});
+/**
+* Update a member record's mutable fields such as `roleIds`, `status`, and
+* `extend`.
+*
+* Uses `db.patch` under the hood, so only the fields present in `data` are
+* modified — all other fields on the member document are left unchanged.
+*
+* @param args.memberId - The `Id<"GroupMember">` of the member record to update.
+* @param args.data - A partial object of fields to patch. Supported keys include `roleIds`, `status`, and `extend`.
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* await ctx.runMutation(components.auth.groups.memberUpdate, {
+*   memberId: existingMemberId,
+*   data: {
+*     roleIds: ["admin", "editor"],
+*     status: "active",
+*   },
+* });
+* ```
+*/
+const memberUpdate = mutation({
+	args: {
+		memberId: v.id("GroupMember"),
+		data: v.any()
+	},
+	returns: v.null(),
+	handler: async (ctx, { memberId, data }) => {
+		await ctx.db.patch("GroupMember", memberId, data);
+		return null;
+	}
+});
+
+//#endregion
+export { memberAdd, memberGet, memberGetByGroupAndUser, memberList, memberRemove, memberResolve, memberUpdate };
+//# sourceMappingURL=members.js.map

package/dist/component/public/groups/members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"members.js","names":[],"sources":["../../../../src/component/public/groups/members.ts"],"sourcesContent":["import { ConvexError, v } from \"convex/values\";\nimport type { Id } from \"../../_generated/dataModel\";\nimport { mutation, query } from \"../../functions\";\nimport { vGroupMemberDoc, vPaginated } from \"../../model\";\n\n/**\n * Add a user as a member of a group.\n *\n * The `roleIds` field stores application-defined role identifiers. The auth\n * component stores assignments but does not enforce access control — your\n * application defines what each role means.\n *\n * Throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` when the user is\n * already a member of the target group. The duplicate check uses the\n * `group_id_user_id` compound index for an exact match.\n *\n * @param args.groupId - The `Id<\"Group\">` of the group to add the user to.\n * @param args.userId - The `Id<\"User\">` of the user to add as a member.\n * @param args.roleIds - Optional array of application-defined role identifiers (e.g. `[\"admin\", \"editor\"]`).\n * @param args.status - Optional membership status string (e.g. `\"active\"`, `\"suspended\"`). Defaults to whatever your application convention is.\n * @param args.extend - Optional arbitrary payload for application-specific metadata on the membership.\n * @returns The `Id<\"GroupMember\">` of the newly created member document.\n * @throws `ConvexError` with code `DUPLICATE_MEMBERSHIP` if the user is already a member of this group.\n *\n * @example\n * ```ts\n * const memberId = await ctx.runMutation(\n *   components.auth.groups.memberAdd,\n *   {\n *     groupId: teamGroupId,\n *     userId: newUserId,\n *     roleIds: [\"viewer\"],\n *     status: \"active\",\n *   },\n * );\n * ```\n */\nexport const memberAdd = mutation({\n  args: {\n    groupId: v.id(\"Group\"),\n    userId: v.id(\"User\"),\n    roleIds: v.optional(v.array(v.string())),\n    status: v.optional(v.string()),\n    extend: v.optional(v.any()),\n  },\n  returns: v.id(\"GroupMember\"),\n  handler: async (ctx, args) => {\n    const existingMembership = await ctx.db\n      .query(\"GroupMember\")\n      .withIndex(\"group_id_user_id\", (q) =>\n        q.eq(\"groupId\", args.groupId).eq(\"userId\", args.userId),\n      )\n      .unique();\n    if (existingMembership !== null) {\n      throw new ConvexError({\n        code: \"DUPLICATE_MEMBERSHIP\",\n        message: \"User is already a member of this group\",\n        groupId: args.groupId,\n        userId: args.userId,\n        existingMemberId: existingMembership._id,\n      });\n    }\n    return await ctx.db.insert(\"GroupMember\", args);\n  },\n});\n\n/**\n * Retrieve a member record by its document ID.\n *\n * Performs a direct lookup in the `GroupMember` table and returns the full\n * member document, or `null` if no member exists with the given ID.\n *\n * @param args.memberId - The `Id<\"GroupMember\">` of the member record to retrieve.\n * @returns The member document (including `groupId`, `userId`, `roleIds`, `status`, etc.) or `null` if not found.\n *\n * @example\n * ```ts\n * const member = await ctx.runQuery(components.auth.groups.memberGet, {\n *   memberId: existingMemberId,\n * });\n * if (member !== null) {\n *   console.log(member.userId, member.roleIds);\n * }\n * ```\n */\nexport const memberGet = query({\n  args: { memberId: v.id(\"GroupMember\") },\n  returns: v.union(vGroupMemberDoc, v.null()),\n  handler: async (ctx, { memberId }) => {\n    return await ctx.db.get(\"GroupMember\", memberId);\n  },\n});\n\n/**\n * List members with optional filtering, sorting, and pagination.\n *\n * Returns `{ items, nextCursor }`. Supports filtering by `groupId`,\n * `userId`, `roleId`, and `status`. The query engine automatically selects\n * the best compound index based on the combination of filter fields\n * provided. The `roleId` filter is applied in-memory after the index scan\n * because role IDs are stored as an array.\n *\n * @param args.where - Optional filter criteria for narrowing results.\n * @param args.where.groupId - Match members belonging to this group.\n * @param args.where.userId - Match members for this specific user.\n * @param args.where.roleId - Match members whose `roleIds` array includes this role identifier.\n * @param args.where.status - Match members with this exact status string (e.g. `\"active\"`).\n * @param args.limit - Maximum number of items per page (clamped to 1..100, defaults to 50).\n * @param args.cursor - An opaque cursor string from a previous response's `nextCursor` to fetch the next page, or `null` to start from the beginning.\n * @param args.orderBy - The field to sort by: `\"_creationTime\"` or `\"status\"`.\n * @param args.order - Sort direction: `\"asc\"` or `\"desc\"` (defaults to `\"desc\"`).\n * @returns An object `{ items, nextCursor }` where `items` is an array of member documents and `nextCursor` is `null` when there are no more pages.\n *\n * @example\n * ```ts\n * const { items, nextCursor } = await ctx.runQuery(\n *   components.auth.groups.memberList,\n *   {\n *     where: { groupId: teamGroupId, status: \"active\" },\n *     limit: 30,\n *     order: \"asc\",\n *   },\n * );\n * ```\n */\nexport const memberList = query({\n  args: {\n    where: v.optional(\n      v.object({\n        groupId: v.optional(v.id(\"Group\")),\n        userId: v.optional(v.id(\"User\")),\n        roleId: v.optional(v.string()),\n        status: v.optional(v.string()),\n      }),\n    ),\n    limit: v.optional(v.number()),\n    cursor: v.optional(v.union(v.string(), v.null())),\n    orderBy: v.optional(\n      v.union(v.literal(\"_creationTime\"), v.literal(\"status\")),\n    ),\n    order: v.optional(v.union(v.literal(\"asc\"), v.literal(\"desc\"))),\n  },\n  returns: vPaginated(vGroupMemberDoc),\n  handler: async (ctx, args) => {\n    const where = args.where ?? {};\n    const limit = Math.min(Math.max(args.limit ?? 50, 1), 100);\n    const order = args.order ?? \"desc\";\n\n    let q;\n    if (where.groupId !== undefined && where.userId !== undefined) {\n      q = ctx.db\n        .query(\"GroupMember\")\n        .withIndex(\"group_id_user_id\", (idx) =>\n          idx.eq(\"groupId\", where.groupId!).eq(\"userId\", where.userId!),\n        );\n      if (where.status !== undefined) {\n        q = q.filter((f) => f.eq(f.field(\"status\"), where.status!));\n      }\n    } else if (where.groupId !== undefined && where.status !== undefined) {\n      q = ctx.db\n        .query(\"GroupMember\")\n        .withIndex(\"group_id_status\", (idx) =>\n          idx.eq(\"groupId\", where.groupId!).eq(\"status\", where.status!),\n        );\n    } else if (where.groupId !== undefined) {\n      q = ctx.db\n        .query(\"GroupMember\")\n        .withIndex(\"group_id\", (idx) => idx.eq(\"groupId\", where.groupId!));\n    } else if (where.userId !== undefined) {\n      q = ctx.db\n        .query(\"GroupMember\")\n        .withIndex(\"user_id\", (idx) => idx.eq(\"userId\", where.userId!));\n      if (where.status !== undefined) {\n        q = q.filter((f) => f.eq(f.field(\"status\"), where.status!));\n      }\n    } else {\n      q = ctx.db.query(\"GroupMember\");\n      if (where.status !== undefined) {\n        q = q.filter((f) => f.eq(f.field(\"status\"), where.status!));\n      }\n    }\n\n    q = q.order(order);\n\n    let all = await q.collect();\n    if (where.roleId !== undefined) {\n      all = all.filter((doc) => (doc.roleIds ?? []).includes(where.roleId!));\n    }\n    let startIdx = 0;\n    if (args.cursor) {\n      const cursorIdx = all.findIndex((doc) => doc._id === args.cursor);\n      if (cursorIdx !== -1) {\n        startIdx = cursorIdx + 1;\n      }\n    }\n    const page = all.slice(startIdx, startIdx + limit + 1);\n    const hasMore = page.length > limit;\n    const items = hasMore ? page.slice(0, limit) : page;\n    const nextCursor = hasMore ? items[items.length - 1]._id : null;\n    return { items, nextCursor };\n  },\n});\n\n/**\n * Look up a specific user's membership in a specific group.\n *\n * Uses the `group_id_user_id` compound index for an efficient exact-match\n * lookup. Returns `null` if the user is not a member of the group. Unlike\n * {@link memberResolve}, this does **not** walk the group hierarchy — it\n * checks only the specified group.\n *\n * @param args.groupId - The `Id<\"Group\">` of the group to check.\n * @param args.userId - The `Id<\"User\">` of the user whose membership to look up.\n * @returns The member document or `null` if the user is not a direct member of the group.\n *\n * @example\n * ```ts\n * const member = await ctx.runQuery(\n *   components.auth.groups.memberGetByGroupAndUser,\n *   { groupId: teamGroupId, userId: currentUserId },\n * );\n * if (member !== null) {\n *   console.log(\"User has roles:\", member.roleIds);\n * }\n * ```\n */\nexport const memberGetByGroupAndUser = query({\n  args: { groupId: v.id(\"Group\"), userId: v.id(\"User\") },\n  returns: v.union(vGroupMemberDoc, v.null()),\n  handler: async (ctx, { groupId, userId }) => {\n    return await ctx.db\n      .query(\"GroupMember\")\n      .withIndex(\"group_id_user_id\", (q) =>\n        q.eq(\"groupId\", groupId).eq(\"userId\", userId),\n      )\n      .unique();\n  },\n});\n\n/**\n * Resolve a user's membership by walking the group hierarchy from the\n * requested group up to the root. Returns the first matching membership\n * found, enabling inherited (ancestor-level) access checks.\n *\n * The traversal walks from `groupId` to its `parentGroupId`, then to the\n * parent's parent, and so on, up to `maxDepth` levels (default 32). It\n * stops at the first group where the user has a membership record. Cycle\n * detection prevents infinite loops if the hierarchy is malformed.\n *\n * When `ancestry` is `true`, the response includes a `traversedGroupIds`\n * array showing the full path that was walked (useful for debugging or\n * audit trails).\n *\n * This runs entirely inside the component (no cross-component RPCs per level).\n *\n * @param args.userId - The `Id<\"User\">` of the user whose membership to resolve.\n * @param args.groupId - The `Id<\"Group\">` to start the upward traversal from.\n * @param args.maxDepth - Optional maximum number of parent levels to traverse (defaults to 32). Set to `0` to check only the exact group.\n * @param args.ancestry - When `true`, the response includes the `traversedGroupIds` array showing all group IDs visited during the walk.\n * @returns An object with:\n *   - `membership` — the member document at the matched group, or `null` if none was found.\n *   - `matchedGroupId` — the ID of the group where membership was found, or `null`.\n *   - `depth` — how many levels above `groupId` the match was found (0 = direct), or `null` if not found.\n *   - `isDirect` — `true` when `depth === 0`.\n *   - `isInherited` — `true` when `depth > 0`.\n *   - `traversedGroupIds` — (only when `ancestry` is `true`) array of group IDs visited.\n *\n * @example\n * ```ts\n * const result = await ctx.runQuery(\n *   components.auth.groups.memberResolve,\n *   {\n *     userId: currentUserId,\n *     groupId: subTeamGroupId,\n *     maxDepth: 5,\n *     ancestry: true,\n *   },\n * );\n * if (result.membership !== null) {\n *   console.log(\n *     result.isDirect ? \"Direct member\" : `Inherited from depth ${result.depth}`,\n *   );\n * }\n * ```\n */\nexport const memberResolve = query({\n  args: {\n    userId: v.id(\"User\"),\n    groupId: v.id(\"Group\"),\n    maxDepth: v.optional(v.number()),\n    ancestry: v.optional(v.boolean()),\n  },\n  returns: v.object({\n    membership: v.union(vGroupMemberDoc, v.null()),\n    matchedGroupId: v.union(v.id(\"Group\"), v.null()),\n    depth: v.union(v.number(), v.null()),\n    isDirect: v.boolean(),\n    isInherited: v.boolean(),\n    traversedGroupIds: v.optional(v.array(v.id(\"Group\"))),\n  }),\n  handler: async (ctx, args) => {\n    const maxDepth = Math.max(0, Math.floor(args.maxDepth ?? 32));\n    const includeAncestry = args.ancestry ?? false;\n    const visited = new Set<string>();\n    const traversedGroupIds: Id<\"Group\">[] = [];\n    let currentGroupId: Id<\"Group\"> | undefined = args.groupId;\n    let depth = 0;\n\n    while (currentGroupId !== undefined && depth <= maxDepth) {\n      if (visited.has(currentGroupId)) break;\n      visited.add(currentGroupId);\n      if (includeAncestry) traversedGroupIds.push(currentGroupId);\n\n      const membership = await ctx.db\n        .query(\"GroupMember\")\n        .withIndex(\"group_id_user_id\", (q) =>\n          q.eq(\"groupId\", currentGroupId!).eq(\"userId\", args.userId),\n        )\n        .unique();\n\n      if (membership !== null) {\n        return {\n          membership,\n          matchedGroupId: currentGroupId,\n          depth,\n          isDirect: depth === 0,\n          isInherited: depth > 0,\n          ...(includeAncestry ? { traversedGroupIds } : {}),\n        };\n      }\n\n      const groupDoc: { parentGroupId?: Id<\"Group\"> } | null =\n        await ctx.db.get(currentGroupId);\n      if (!groupDoc?.parentGroupId) break;\n      currentGroupId = groupDoc.parentGroupId;\n      depth++;\n    }\n\n    return {\n      membership: null,\n      matchedGroupId: null,\n      depth: null,\n      isDirect: false,\n      isInherited: false,\n      ...(includeAncestry ? { traversedGroupIds } : {}),\n    };\n  },\n});\n\n/**\n * Remove a member from a group by permanently deleting the member record.\n *\n * This is a hard delete — the `GroupMember` document is removed from the\n * database entirely. If you need soft-delete semantics, use\n * {@link memberUpdate} to set the `status` field instead.\n *\n * @param args.memberId - The `Id<\"GroupMember\">` of the member record to delete.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(components.auth.groups.memberRemove, {\n *   memberId: memberToRemoveId,\n * });\n * ```\n */\nexport const memberRemove = mutation({\n  args: { memberId: v.id(\"GroupMember\") },\n  returns: v.null(),\n  handler: async (ctx, { memberId }) => {\n    await ctx.db.delete(\"GroupMember\", memberId);\n    return null;\n  },\n});\n\n/**\n * Update a member record's mutable fields such as `roleIds`, `status`, and\n * `extend`.\n *\n * Uses `db.patch` under the hood, so only the fields present in `data` are\n * modified — all other fields on the member document are left unchanged.\n *\n * @param args.memberId - The `Id<\"GroupMember\">` of the member record to update.\n * @param args.data - A partial object of fields to patch. Supported keys include `roleIds`, `status`, and `extend`.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(components.auth.groups.memberUpdate, {\n *   memberId: existingMemberId,\n *   data: {\n *     roleIds: [\"admin\", \"editor\"],\n *     status: \"active\",\n *   },\n * });\n * ```\n */\nexport const memberUpdate = mutation({\n  args: { memberId: v.id(\"GroupMember\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { memberId, data }) => {\n    await ctx.db.patch(\"GroupMember\", memberId, data);\n    return null;\n  },\n});\n\n// ============================================================================\n// Invites\n// ============================================================================\n"],"mappings":"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"}