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

package/dist/component/public/identity/users.js

@@ -0,0 +1,311 @@
+import { mutation, query } from "../../functions.js";
+import { vPaginated, vUserDoc } from "../../model.js";
+import { v } from "convex/values";
+
+//#region src/component/public/identity/users.ts
+/**
+* List users with optional filtering, sorting, and cursor-based pagination.
+*
+* Supports filtering by `email`, `phone`, `isAnonymous`, and `name`. When an
+* `email` or `phone` filter is provided, the corresponding database index is
+* used for efficient lookup; other filters are applied in-memory. Results are
+* returned as a paginated response `{ items, nextCursor }` -- pass `nextCursor`
+* back as `cursor` to fetch the next page, or receive `null` when all results
+* have been exhausted.
+*
+* @param args.where - Optional filter object. Fields: `email` (exact match),
+*   `phone` (exact match), `isAnonymous` (boolean), `name` (exact match).
+* @param args.limit - Maximum number of users to return per page (1--100, default 50).
+* @param args.cursor - An opaque cursor string from a previous response's `nextCursor`
+*   to continue pagination, or `null` / omitted to start from the beginning.
+* @param args.orderBy - The field to sort results by. One of `"_creationTime"`,
+*   `"name"`, `"email"`, or `"phone"`. Defaults to `"_creationTime"`.
+* @param args.order - Sort direction: `"asc"` or `"desc"` (default `"desc"`).
+* @returns An object with `items` (array of user documents) and `nextCursor`
+*   (`string | null`) for fetching subsequent pages.
+*
+* @example
+* ```ts
+* // Fetch the first page of non-anonymous users
+* const page1 = await ctx.runQuery(
+*   component.identity.users.userList,
+*   { where: { isAnonymous: false }, limit: 20 },
+* );
+* console.log(page1.items);
+*
+* // Fetch the next page
+* if (page1.nextCursor !== null) {
+*   const page2 = await ctx.runQuery(
+*     component.identity.users.userList,
+*     { where: { isAnonymous: false }, limit: 20, cursor: page1.nextCursor },
+*   );
+* }
+* ```
+*/
+const userList = query({
+	args: {
+		where: v.optional(v.object({
+			email: v.optional(v.string()),
+			phone: v.optional(v.string()),
+			isAnonymous: v.optional(v.boolean()),
+			name: 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("name"), v.literal("email"), v.literal("phone"))),
+		order: v.optional(v.union(v.literal("asc"), v.literal("desc")))
+	},
+	returns: vPaginated(vUserDoc),
+	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.email !== void 0) q = ctx.db.query("User").withIndex("email", (idx) => idx.eq("email", where.email));
+		else if (where.phone !== void 0) q = ctx.db.query("User").withIndex("phone", (idx) => idx.eq("phone", where.phone));
+		else q = ctx.db.query("User");
+		if (where.isAnonymous !== void 0) q = q.filter((f) => f.eq(f.field("isAnonymous"), where.isAnonymous));
+		if (where.name !== void 0) q = q.filter((f) => f.eq(f.field("name"), where.name));
+		if (where.email !== void 0 && where.phone !== void 0) q = q.filter((f) => f.eq(f.field("phone"), where.phone));
+		q = q.order(order);
+		const all = await q.collect();
+		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
+		};
+	}
+});
+/**
+* Retrieve a single user by their Convex document ID.
+*
+* Performs a direct point lookup on the `User` table. Returns `null` if the
+* user has been deleted or never existed.
+*
+* @param args.userId - The Convex document ID (`Id<"User">`) of the user to retrieve.
+* @returns The user document if it exists, or `null` otherwise.
+*
+* @example
+* ```ts
+* const user = await ctx.runQuery(
+*   component.identity.users.userGetById,
+*   { userId: session.userId },
+* );
+* if (user !== null) {
+*   console.log(`Name: ${user.name}, Email: ${user.email}`);
+* }
+* ```
+*/
+const userGetById = query({
+	args: { userId: v.id("User") },
+	returns: v.union(vUserDoc, v.null()),
+	handler: async (ctx, { userId }) => {
+		return await ctx.db.get("User", userId);
+	}
+});
+/**
+* Find a user by their verified email address.
+*
+* Queries the `User` table using the `email_verified` index to locate users
+* whose `email` matches and whose `emailVerificationTime` is set. If exactly
+* one user is found, that document is returned. Returns `null` if no user has
+* this email verified or if multiple users share the same verified email
+* (an ambiguous state that should not occur in normal operation).
+*
+* @param args.email - The verified email address to search for (case-sensitive, exact match).
+* @returns The matching user document if exactly one verified user is found, or `null` otherwise.
+*
+* @example
+* ```ts
+* const user = await ctx.runQuery(
+*   component.identity.users.userFindByVerifiedEmail,
+*   { email: "alice@example.com" },
+* );
+* if (user !== null) {
+*   console.log(`Found verified user: ${user._id}`);
+* }
+* ```
+*/
+const userFindByVerifiedEmail = query({
+	args: { email: v.string() },
+	returns: v.union(vUserDoc, v.null()),
+	handler: async (ctx, { email }) => {
+		const users = await ctx.db.query("User").withIndex("email_verified", (q) => q.eq("email", email).gt("emailVerificationTime", void 0)).take(2);
+		return users.length === 1 ? users[0] : null;
+	}
+});
+/**
+* Find a user by their verified phone number.
+*
+* Queries the `User` table using the `phone_verified` index to locate users
+* whose `phone` matches and whose `phoneVerificationTime` is set. If exactly
+* one user is found, that document is returned. Returns `null` if no user has
+* this phone verified or if multiple users share the same verified phone
+* (an ambiguous state that should not occur in normal operation).
+*
+* @param args.phone - The verified phone number to search for (exact match, e.g. `"+15551234567"`).
+* @returns The matching user document if exactly one verified user is found, or `null` otherwise.
+*
+* @example
+* ```ts
+* const user = await ctx.runQuery(
+*   component.identity.users.userFindByVerifiedPhone,
+*   { phone: "+15551234567" },
+* );
+* if (user !== null) {
+*   console.log(`Found verified user: ${user._id}`);
+* }
+* ```
+*/
+const userFindByVerifiedPhone = query({
+	args: { phone: v.string() },
+	returns: v.union(vUserDoc, v.null()),
+	handler: async (ctx, { phone }) => {
+		const users = await ctx.db.query("User").withIndex("phone_verified", (q) => q.eq("phone", phone).gt("phoneVerificationTime", void 0)).take(2);
+		return users.length === 1 ? users[0] : null;
+	}
+});
+/**
+* Insert a new user document into the `User` table.
+*
+* Creates a brand-new user record. The `data` argument should conform to the
+* User table schema (e.g. `name`, `email`, `phone`, `isAnonymous`, `image`,
+* `extend`), but is typed as `any` to allow flexible extension.
+*
+* @param args.data - The user document fields to insert. Typically includes `name`,
+*   `email`, `isAnonymous`, and any custom fields under `extend`.
+* @returns The document ID of the newly created user.
+*
+* @example
+* ```ts
+* const userId = await ctx.runMutation(
+*   component.identity.users.userInsert,
+*   {
+*     data: {
+*       name: "Alice",
+*       email: "alice@example.com",
+*       isAnonymous: false,
+*     },
+*   },
+* );
+* ```
+*/
+const userInsert = mutation({
+	args: { data: v.any() },
+	returns: v.id("User"),
+	handler: async (ctx, { data }) => {
+		return await ctx.db.insert("User", data);
+	}
+});
+/**
+* Insert a new user or update an existing one (upsert).
+*
+* When `userId` is provided and refers to an existing user, the document is
+* patched with the supplied `data` and the same `userId` is returned. When
+* `userId` is omitted or `undefined`, a new user document is inserted and its
+* generated ID is returned. This is the primary mechanism used during sign-in
+* flows to either create or refresh user profile data.
+*
+* @param args.userId - The document ID of an existing user to update. If `undefined`,
+*   a new user is created instead.
+* @param args.data - The user document fields to insert or merge. Accepts the same
+*   shape as the User table schema.
+* @returns The document ID of the created or updated user.
+*
+* @example
+* ```ts
+* // Create a new user if none exists, or update the existing one
+* const userId = await ctx.runMutation(
+*   component.identity.users.userUpsert,
+*   {
+*     userId: existingUserId ?? undefined,
+*     data: { name: "Alice", email: "alice@example.com" },
+*   },
+* );
+* ```
+*/
+const userUpsert = mutation({
+	args: {
+		userId: v.optional(v.id("User")),
+		data: v.any()
+	},
+	returns: v.id("User"),
+	handler: async (ctx, { userId, data }) => {
+		if (userId !== void 0) {
+			await ctx.db.patch("User", userId, data);
+			return userId;
+		}
+		return await ctx.db.insert("User", data);
+	}
+});
+/**
+* Patch an existing user document with partial data.
+*
+* Merges the provided fields into the existing user document. Fields not
+* included in `data` are left unchanged. Useful for updating profile
+* information such as `name`, `email`, or custom `extend` fields without
+* overwriting the entire document.
+*
+* @param args.userId - The document ID of the user to update.
+* @param args.data - A partial object containing the fields to merge into the user document.
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* await ctx.runMutation(
+*   component.identity.users.userPatch,
+*   {
+*     userId: user._id,
+*     data: { name: "Alice Smith", image: "https://example.com/avatar.png" },
+*   },
+* );
+* ```
+*/
+const userPatch = mutation({
+	args: {
+		userId: v.id("User"),
+		data: v.any()
+	},
+	returns: v.null(),
+	handler: async (ctx, { userId, data }) => {
+		await ctx.db.patch("User", userId, data);
+		return null;
+	}
+});
+/**
+* Delete a user document by ID.
+*
+* Removes the user from the `User` table. This is a no-op if the user does not
+* exist (i.e. was already deleted). Callers should ensure that related resources
+* such as accounts, sessions, and refresh tokens are cleaned up separately.
+*
+* @param args.userId - The document ID of the user to delete.
+* @returns `null` on success (including when the user was already absent).
+*
+* @example
+* ```ts
+* await ctx.runMutation(
+*   component.identity.users.userDelete,
+*   { userId: user._id },
+* );
+* ```
+*/
+const userDelete = mutation({
+	args: { userId: v.id("User") },
+	returns: v.null(),
+	handler: async (ctx, { userId }) => {
+		if (await ctx.db.get("User", userId) !== null) await ctx.db.delete("User", userId);
+		return null;
+	}
+});
+
+//#endregion
+export { userDelete, userFindByVerifiedEmail, userFindByVerifiedPhone, userGetById, userInsert, userList, userPatch, userUpsert };
+//# sourceMappingURL=users.js.map

package/dist/component/public/identity/users.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.js","names":[],"sources":["../../../../src/component/public/identity/users.ts"],"sourcesContent":["import { v } from \"convex/values\";\nimport { mutation, query } from \"../../functions\";\nimport { vPaginated, vUserDoc } from \"../../model\";\n\n/**\n * List users with optional filtering, sorting, and cursor-based pagination.\n *\n * Supports filtering by `email`, `phone`, `isAnonymous`, and `name`. When an\n * `email` or `phone` filter is provided, the corresponding database index is\n * used for efficient lookup; other filters are applied in-memory. Results are\n * returned as a paginated response `{ items, nextCursor }` -- pass `nextCursor`\n * back as `cursor` to fetch the next page, or receive `null` when all results\n * have been exhausted.\n *\n * @param args.where - Optional filter object. Fields: `email` (exact match),\n *   `phone` (exact match), `isAnonymous` (boolean), `name` (exact match).\n * @param args.limit - Maximum number of users to return per page (1--100, default 50).\n * @param args.cursor - An opaque cursor string from a previous response's `nextCursor`\n *   to continue pagination, or `null` / omitted to start from the beginning.\n * @param args.orderBy - The field to sort results by. One of `\"_creationTime\"`,\n *   `\"name\"`, `\"email\"`, or `\"phone\"`. Defaults to `\"_creationTime\"`.\n * @param args.order - Sort direction: `\"asc\"` or `\"desc\"` (default `\"desc\"`).\n * @returns An object with `items` (array of user documents) and `nextCursor`\n *   (`string | null`) for fetching subsequent pages.\n *\n * @example\n * ```ts\n * // Fetch the first page of non-anonymous users\n * const page1 = await ctx.runQuery(\n *   component.identity.users.userList,\n *   { where: { isAnonymous: false }, limit: 20 },\n * );\n * console.log(page1.items);\n *\n * // Fetch the next page\n * if (page1.nextCursor !== null) {\n *   const page2 = await ctx.runQuery(\n *     component.identity.users.userList,\n *     { where: { isAnonymous: false }, limit: 20, cursor: page1.nextCursor },\n *   );\n * }\n * ```\n */\nexport const userList = query({\n  args: {\n    where: v.optional(\n      v.object({\n        email: v.optional(v.string()),\n        phone: v.optional(v.string()),\n        isAnonymous: v.optional(v.boolean()),\n        name: 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(\n        v.literal(\"_creationTime\"),\n        v.literal(\"name\"),\n        v.literal(\"email\"),\n        v.literal(\"phone\"),\n      ),\n    ),\n    order: v.optional(v.union(v.literal(\"asc\"), v.literal(\"desc\"))),\n  },\n  returns: vPaginated(vUserDoc),\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    // Pick index based on where fields\n    let q;\n    if (where.email !== undefined) {\n      q = ctx.db\n        .query(\"User\")\n        .withIndex(\"email\", (idx) => idx.eq(\"email\", where.email!));\n    } else if (where.phone !== undefined) {\n      q = ctx.db\n        .query(\"User\")\n        .withIndex(\"phone\", (idx) => idx.eq(\"phone\", where.phone!));\n    } else {\n      q = ctx.db.query(\"User\");\n    }\n\n    // Apply remaining filters\n    if (where.isAnonymous !== undefined) {\n      q = q.filter((f) => f.eq(f.field(\"isAnonymous\"), where.isAnonymous!));\n    }\n    if (where.name !== undefined) {\n      q = q.filter((f) => f.eq(f.field(\"name\"), where.name!));\n    }\n    // email/phone filters when not used as index\n    if (where.email !== undefined && where.phone !== undefined) {\n      q = q.filter((f) => f.eq(f.field(\"phone\"), where.phone!));\n    }\n\n    q = q.order(order);\n\n    // Cursor-based pagination: skip past the cursor ID\n    const all = await q.collect();\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 * Retrieve a single user by their Convex document ID.\n *\n * Performs a direct point lookup on the `User` table. Returns `null` if the\n * user has been deleted or never existed.\n *\n * @param args.userId - The Convex document ID (`Id<\"User\">`) of the user to retrieve.\n * @returns The user document if it exists, or `null` otherwise.\n *\n * @example\n * ```ts\n * const user = await ctx.runQuery(\n *   component.identity.users.userGetById,\n *   { userId: session.userId },\n * );\n * if (user !== null) {\n *   console.log(`Name: ${user.name}, Email: ${user.email}`);\n * }\n * ```\n */\nexport const userGetById = query({\n  args: { userId: v.id(\"User\") },\n  returns: v.union(vUserDoc, v.null()),\n  handler: async (ctx, { userId }) => {\n    return await ctx.db.get(\"User\", userId);\n  },\n});\n\n/**\n * Find a user by their verified email address.\n *\n * Queries the `User` table using the `email_verified` index to locate users\n * whose `email` matches and whose `emailVerificationTime` is set. If exactly\n * one user is found, that document is returned. Returns `null` if no user has\n * this email verified or if multiple users share the same verified email\n * (an ambiguous state that should not occur in normal operation).\n *\n * @param args.email - The verified email address to search for (case-sensitive, exact match).\n * @returns The matching user document if exactly one verified user is found, or `null` otherwise.\n *\n * @example\n * ```ts\n * const user = await ctx.runQuery(\n *   component.identity.users.userFindByVerifiedEmail,\n *   { email: \"alice@example.com\" },\n * );\n * if (user !== null) {\n *   console.log(`Found verified user: ${user._id}`);\n * }\n * ```\n */\nexport const userFindByVerifiedEmail = query({\n  args: { email: v.string() },\n  returns: v.union(vUserDoc, v.null()),\n  handler: async (ctx, { email }) => {\n    const users = await ctx.db\n      .query(\"User\")\n      .withIndex(\"email_verified\", (q) =>\n        q.eq(\"email\", email).gt(\"emailVerificationTime\", undefined),\n      )\n      .take(2);\n    return users.length === 1 ? users[0] : null;\n  },\n});\n\n/**\n * Find a user by their verified phone number.\n *\n * Queries the `User` table using the `phone_verified` index to locate users\n * whose `phone` matches and whose `phoneVerificationTime` is set. If exactly\n * one user is found, that document is returned. Returns `null` if no user has\n * this phone verified or if multiple users share the same verified phone\n * (an ambiguous state that should not occur in normal operation).\n *\n * @param args.phone - The verified phone number to search for (exact match, e.g. `\"+15551234567\"`).\n * @returns The matching user document if exactly one verified user is found, or `null` otherwise.\n *\n * @example\n * ```ts\n * const user = await ctx.runQuery(\n *   component.identity.users.userFindByVerifiedPhone,\n *   { phone: \"+15551234567\" },\n * );\n * if (user !== null) {\n *   console.log(`Found verified user: ${user._id}`);\n * }\n * ```\n */\nexport const userFindByVerifiedPhone = query({\n  args: { phone: v.string() },\n  returns: v.union(vUserDoc, v.null()),\n  handler: async (ctx, { phone }) => {\n    const users = await ctx.db\n      .query(\"User\")\n      .withIndex(\"phone_verified\", (q) =>\n        q.eq(\"phone\", phone).gt(\"phoneVerificationTime\", undefined),\n      )\n      .take(2);\n    return users.length === 1 ? users[0] : null;\n  },\n});\n\n/**\n * Insert a new user document into the `User` table.\n *\n * Creates a brand-new user record. The `data` argument should conform to the\n * User table schema (e.g. `name`, `email`, `phone`, `isAnonymous`, `image`,\n * `extend`), but is typed as `any` to allow flexible extension.\n *\n * @param args.data - The user document fields to insert. Typically includes `name`,\n *   `email`, `isAnonymous`, and any custom fields under `extend`.\n * @returns The document ID of the newly created user.\n *\n * @example\n * ```ts\n * const userId = await ctx.runMutation(\n *   component.identity.users.userInsert,\n *   {\n *     data: {\n *       name: \"Alice\",\n *       email: \"alice@example.com\",\n *       isAnonymous: false,\n *     },\n *   },\n * );\n * ```\n */\nexport const userInsert = mutation({\n  args: { data: v.any() },\n  returns: v.id(\"User\"),\n  handler: async (ctx, { data }) => {\n    return await ctx.db.insert(\"User\", data);\n  },\n});\n\n/**\n * Insert a new user or update an existing one (upsert).\n *\n * When `userId` is provided and refers to an existing user, the document is\n * patched with the supplied `data` and the same `userId` is returned. When\n * `userId` is omitted or `undefined`, a new user document is inserted and its\n * generated ID is returned. This is the primary mechanism used during sign-in\n * flows to either create or refresh user profile data.\n *\n * @param args.userId - The document ID of an existing user to update. If `undefined`,\n *   a new user is created instead.\n * @param args.data - The user document fields to insert or merge. Accepts the same\n *   shape as the User table schema.\n * @returns The document ID of the created or updated user.\n *\n * @example\n * ```ts\n * // Create a new user if none exists, or update the existing one\n * const userId = await ctx.runMutation(\n *   component.identity.users.userUpsert,\n *   {\n *     userId: existingUserId ?? undefined,\n *     data: { name: \"Alice\", email: \"alice@example.com\" },\n *   },\n * );\n * ```\n */\nexport const userUpsert = mutation({\n  args: { userId: v.optional(v.id(\"User\")), data: v.any() },\n  returns: v.id(\"User\"),\n  handler: async (ctx, { userId, data }) => {\n    if (userId !== undefined) {\n      await ctx.db.patch(\"User\", userId, data);\n      return userId;\n    }\n    return await ctx.db.insert(\"User\", data);\n  },\n});\n\n/**\n * Patch an existing user document with partial data.\n *\n * Merges the provided fields into the existing user document. Fields not\n * included in `data` are left unchanged. Useful for updating profile\n * information such as `name`, `email`, or custom `extend` fields without\n * overwriting the entire document.\n *\n * @param args.userId - The document ID of the user to update.\n * @param args.data - A partial object containing the fields to merge into the user document.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   component.identity.users.userPatch,\n *   {\n *     userId: user._id,\n *     data: { name: \"Alice Smith\", image: \"https://example.com/avatar.png\" },\n *   },\n * );\n * ```\n */\nexport const userPatch = mutation({\n  args: { userId: v.id(\"User\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { userId, data }) => {\n    await ctx.db.patch(\"User\", userId, data);\n    return null;\n  },\n});\n\n/**\n * Delete a user document by ID.\n *\n * Removes the user from the `User` table. This is a no-op if the user does not\n * exist (i.e. was already deleted). Callers should ensure that related resources\n * such as accounts, sessions, and refresh tokens are cleaned up separately.\n *\n * @param args.userId - The document ID of the user to delete.\n * @returns `null` on success (including when the user was already absent).\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   component.identity.users.userDelete,\n *   { userId: user._id },\n * );\n * ```\n */\nexport const userDelete = mutation({\n  args: { userId: v.id(\"User\") },\n  returns: v.null(),\n  handler: async (ctx, { userId }) => {\n    if ((await ctx.db.get(\"User\", userId)) !== null) {\n      await ctx.db.delete(\"User\", userId);\n    }\n    return null;\n  },\n});\n\n// ============================================================================\n// Accounts\n// ============================================================================\n"],"mappings":"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"}

package/dist/component/public/identity/verifiers.d.ts

@@ -0,0 +1,116 @@
+declare namespace verifiers_d_exports {
+  export { verifierCreate, verifierDelete, verifierGetById, verifierGetBySignature, verifierPatch };
+}
+/**
+ * Create a new PKCE verifier, optionally linked to a session.
+ *
+ * Inserts a document into the `AuthVerifier` table. Verifiers are used during
+ * OAuth/OIDC flows to implement the PKCE (Proof Key for Code Exchange) pattern,
+ * preventing authorization code interception attacks. The verifier can optionally
+ * be linked to an existing session for session-aware flows.
+ *
+ * @param args.sessionId - An optional session document ID to associate with the verifier.
+ *   When provided, the verifier is scoped to the given session.
+ * @returns The document ID of the newly created verifier.
+ *
+ * @example
+ * ```ts
+ * const verifierId = await ctx.runMutation(
+ *   component.identity.verifiers.verifierCreate,
+ *   { sessionId: session._id },
+ * );
+ * ```
+ */
+declare const verifierCreate: any;
+/**
+ * Retrieve a single verifier by its Convex document ID.
+ *
+ * Performs a direct point lookup on the `AuthVerifier` table. Returns `null` if
+ * the verifier has been deleted or never existed.
+ *
+ * @param args.verifierId - The Convex document ID (`Id<"AuthVerifier">`) of the verifier to retrieve.
+ * @returns The verifier document if it exists, or `null` otherwise.
+ *
+ * @example
+ * ```ts
+ * const verifier = await ctx.runQuery(
+ *   component.identity.verifiers.verifierGetById,
+ *   { verifierId: storedVerifierId },
+ * );
+ * if (verifier !== null) {
+ *   console.log(`Verifier signature: ${verifier.signature}`);
+ * }
+ * ```
+ */
+declare const verifierGetById: any;
+/**
+ * Look up a verifier by its cryptographic signature.
+ *
+ * Queries the `AuthVerifier` table using the `signature` index to find the
+ * unique verifier matching the given signature string. This is the primary
+ * lookup used during the OAuth callback phase to correlate the incoming
+ * authorization response with the original PKCE challenge.
+ *
+ * @param args.signature - The cryptographic signature string to search for (exact match).
+ * @returns The matching verifier document, or `null` if no verifier has the given signature.
+ *
+ * @example
+ * ```ts
+ * const verifier = await ctx.runQuery(
+ *   component.identity.verifiers.verifierGetBySignature,
+ *   { signature: incomingStateParam },
+ * );
+ * if (verifier === null) {
+ *   throw new Error("Invalid or expired OAuth state");
+ * }
+ * ```
+ */
+declare const verifierGetBySignature: any;
+/**
+ * Patch a verifier document with partial data.
+ *
+ * Merges the provided fields into the existing verifier document. This is
+ * typically used to set the `signature` field after the verifier is initially
+ * created, or to associate a `sessionId` with an existing verifier.
+ *
+ * @param args.verifierId - The document ID of the verifier to update.
+ * @param args.data - A partial object containing the fields to merge into the verifier document
+ *   (e.g. `{ signature: string }` or `{ sessionId: Id<"Session"> }`).
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * // Set the PKCE signature on the verifier
+ * await ctx.runMutation(
+ *   component.identity.verifiers.verifierPatch,
+ *   {
+ *     verifierId: verifier._id,
+ *     data: { signature: generatedSignature },
+ *   },
+ * );
+ * ```
+ */
+declare const verifierPatch: any;
+/**
+ * Delete a verifier document permanently.
+ *
+ * Removes the verifier from the `AuthVerifier` table. This is typically called
+ * after a successful OAuth callback to clean up the consumed PKCE state, or
+ * to expire stale verifiers that were never completed.
+ *
+ * @param args.verifierId - The document ID of the verifier to delete.
+ * @returns `null` on success.
+ *
+ * @example
+ * ```ts
+ * // Clean up the verifier after a successful OAuth exchange
+ * await ctx.runMutation(
+ *   component.identity.verifiers.verifierDelete,
+ *   { verifierId: verifier._id },
+ * );
+ * ```
+ */
+declare const verifierDelete: any;
+//#endregion
+export { verifierCreate, verifierDelete, verifierGetById, verifierGetBySignature, verifierPatch, verifiers_d_exports };
+//# sourceMappingURL=verifiers.d.ts.map

package/dist/component/public/identity/verifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifiers.d.ts","names":[],"sources":["../../../../src/component/public/identity/verifiers.ts"],"mappings":";;;;;;;;;;;;;AAwBA;;;;;AA4BA;;;;;cA5Ba,cAAA;;;;;AA6Fb;;;;;AA4BA;;;;;;;;;;;cA7Fa,eAAA;;;;;;;;;;;;;;;;;;;;;;;cA8BA,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;cAmCA,aAAA;;;;;;;;;;;;;;;;;;;;cA4BA,cAAA"}

package/dist/component/public/identity/verifiers.js

@@ -0,0 +1,154 @@
+import { mutation, query } from "../../functions.js";
+import { vAuthVerifierDoc } from "../../model.js";
+import { v } from "convex/values";
+
+//#region src/component/public/identity/verifiers.ts
+/**
+* Create a new PKCE verifier, optionally linked to a session.
+*
+* Inserts a document into the `AuthVerifier` table. Verifiers are used during
+* OAuth/OIDC flows to implement the PKCE (Proof Key for Code Exchange) pattern,
+* preventing authorization code interception attacks. The verifier can optionally
+* be linked to an existing session for session-aware flows.
+*
+* @param args.sessionId - An optional session document ID to associate with the verifier.
+*   When provided, the verifier is scoped to the given session.
+* @returns The document ID of the newly created verifier.
+*
+* @example
+* ```ts
+* const verifierId = await ctx.runMutation(
+*   component.identity.verifiers.verifierCreate,
+*   { sessionId: session._id },
+* );
+* ```
+*/
+const verifierCreate = mutation({
+	args: { sessionId: v.optional(v.id("Session")) },
+	returns: v.id("AuthVerifier"),
+	handler: async (ctx, { sessionId }) => {
+		return await ctx.db.insert("AuthVerifier", { sessionId });
+	}
+});
+/**
+* Retrieve a single verifier by its Convex document ID.
+*
+* Performs a direct point lookup on the `AuthVerifier` table. Returns `null` if
+* the verifier has been deleted or never existed.
+*
+* @param args.verifierId - The Convex document ID (`Id<"AuthVerifier">`) of the verifier to retrieve.
+* @returns The verifier document if it exists, or `null` otherwise.
+*
+* @example
+* ```ts
+* const verifier = await ctx.runQuery(
+*   component.identity.verifiers.verifierGetById,
+*   { verifierId: storedVerifierId },
+* );
+* if (verifier !== null) {
+*   console.log(`Verifier signature: ${verifier.signature}`);
+* }
+* ```
+*/
+const verifierGetById = query({
+	args: { verifierId: v.id("AuthVerifier") },
+	returns: v.union(vAuthVerifierDoc, v.null()),
+	handler: async (ctx, { verifierId }) => {
+		return await ctx.db.get("AuthVerifier", verifierId);
+	}
+});
+/**
+* Look up a verifier by its cryptographic signature.
+*
+* Queries the `AuthVerifier` table using the `signature` index to find the
+* unique verifier matching the given signature string. This is the primary
+* lookup used during the OAuth callback phase to correlate the incoming
+* authorization response with the original PKCE challenge.
+*
+* @param args.signature - The cryptographic signature string to search for (exact match).
+* @returns The matching verifier document, or `null` if no verifier has the given signature.
+*
+* @example
+* ```ts
+* const verifier = await ctx.runQuery(
+*   component.identity.verifiers.verifierGetBySignature,
+*   { signature: incomingStateParam },
+* );
+* if (verifier === null) {
+*   throw new Error("Invalid or expired OAuth state");
+* }
+* ```
+*/
+const verifierGetBySignature = query({
+	args: { signature: v.string() },
+	returns: v.union(vAuthVerifierDoc, v.null()),
+	handler: async (ctx, { signature }) => {
+		return await ctx.db.query("AuthVerifier").withIndex("signature", (q) => q.eq("signature", signature)).unique();
+	}
+});
+/**
+* Patch a verifier document with partial data.
+*
+* Merges the provided fields into the existing verifier document. This is
+* typically used to set the `signature` field after the verifier is initially
+* created, or to associate a `sessionId` with an existing verifier.
+*
+* @param args.verifierId - The document ID of the verifier to update.
+* @param args.data - A partial object containing the fields to merge into the verifier document
+*   (e.g. `{ signature: string }` or `{ sessionId: Id<"Session"> }`).
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* // Set the PKCE signature on the verifier
+* await ctx.runMutation(
+*   component.identity.verifiers.verifierPatch,
+*   {
+*     verifierId: verifier._id,
+*     data: { signature: generatedSignature },
+*   },
+* );
+* ```
+*/
+const verifierPatch = mutation({
+	args: {
+		verifierId: v.id("AuthVerifier"),
+		data: v.any()
+	},
+	returns: v.null(),
+	handler: async (ctx, { verifierId, data }) => {
+		await ctx.db.patch("AuthVerifier", verifierId, data);
+		return null;
+	}
+});
+/**
+* Delete a verifier document permanently.
+*
+* Removes the verifier from the `AuthVerifier` table. This is typically called
+* after a successful OAuth callback to clean up the consumed PKCE state, or
+* to expire stale verifiers that were never completed.
+*
+* @param args.verifierId - The document ID of the verifier to delete.
+* @returns `null` on success.
+*
+* @example
+* ```ts
+* // Clean up the verifier after a successful OAuth exchange
+* await ctx.runMutation(
+*   component.identity.verifiers.verifierDelete,
+*   { verifierId: verifier._id },
+* );
+* ```
+*/
+const verifierDelete = mutation({
+	args: { verifierId: v.id("AuthVerifier") },
+	returns: v.null(),
+	handler: async (ctx, { verifierId }) => {
+		await ctx.db.delete("AuthVerifier", verifierId);
+		return null;
+	}
+});
+
+//#endregion
+export { verifierCreate, verifierDelete, verifierGetById, verifierGetBySignature, verifierPatch };
+//# sourceMappingURL=verifiers.js.map

package/dist/component/public/identity/verifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifiers.js","names":[],"sources":["../../../../src/component/public/identity/verifiers.ts"],"sourcesContent":["import { v } from \"convex/values\";\nimport { mutation, query } from \"../../functions\";\nimport { vAuthVerifierDoc } from \"../../model\";\n\n/**\n * Create a new PKCE verifier, optionally linked to a session.\n *\n * Inserts a document into the `AuthVerifier` table. Verifiers are used during\n * OAuth/OIDC flows to implement the PKCE (Proof Key for Code Exchange) pattern,\n * preventing authorization code interception attacks. The verifier can optionally\n * be linked to an existing session for session-aware flows.\n *\n * @param args.sessionId - An optional session document ID to associate with the verifier.\n *   When provided, the verifier is scoped to the given session.\n * @returns The document ID of the newly created verifier.\n *\n * @example\n * ```ts\n * const verifierId = await ctx.runMutation(\n *   component.identity.verifiers.verifierCreate,\n *   { sessionId: session._id },\n * );\n * ```\n */\nexport const verifierCreate = mutation({\n  args: { sessionId: v.optional(v.id(\"Session\")) },\n  returns: v.id(\"AuthVerifier\"),\n  handler: async (ctx, { sessionId }) => {\n    return await ctx.db.insert(\"AuthVerifier\", { sessionId: sessionId as any });\n  },\n});\n\n/**\n * Retrieve a single verifier by its Convex document ID.\n *\n * Performs a direct point lookup on the `AuthVerifier` table. Returns `null` if\n * the verifier has been deleted or never existed.\n *\n * @param args.verifierId - The Convex document ID (`Id<\"AuthVerifier\">`) of the verifier to retrieve.\n * @returns The verifier document if it exists, or `null` otherwise.\n *\n * @example\n * ```ts\n * const verifier = await ctx.runQuery(\n *   component.identity.verifiers.verifierGetById,\n *   { verifierId: storedVerifierId },\n * );\n * if (verifier !== null) {\n *   console.log(`Verifier signature: ${verifier.signature}`);\n * }\n * ```\n */\nexport const verifierGetById = query({\n  args: { verifierId: v.id(\"AuthVerifier\") },\n  returns: v.union(vAuthVerifierDoc, v.null()),\n  handler: async (ctx, { verifierId }) => {\n    return await ctx.db.get(\"AuthVerifier\", verifierId);\n  },\n});\n\n/**\n * Look up a verifier by its cryptographic signature.\n *\n * Queries the `AuthVerifier` table using the `signature` index to find the\n * unique verifier matching the given signature string. This is the primary\n * lookup used during the OAuth callback phase to correlate the incoming\n * authorization response with the original PKCE challenge.\n *\n * @param args.signature - The cryptographic signature string to search for (exact match).\n * @returns The matching verifier document, or `null` if no verifier has the given signature.\n *\n * @example\n * ```ts\n * const verifier = await ctx.runQuery(\n *   component.identity.verifiers.verifierGetBySignature,\n *   { signature: incomingStateParam },\n * );\n * if (verifier === null) {\n *   throw new Error(\"Invalid or expired OAuth state\");\n * }\n * ```\n */\nexport const verifierGetBySignature = query({\n  args: { signature: v.string() },\n  returns: v.union(vAuthVerifierDoc, v.null()),\n  handler: async (ctx, { signature }) => {\n    return await ctx.db\n      .query(\"AuthVerifier\")\n      .withIndex(\"signature\", (q) => q.eq(\"signature\", signature))\n      .unique();\n  },\n});\n\n/**\n * Patch a verifier document with partial data.\n *\n * Merges the provided fields into the existing verifier document. This is\n * typically used to set the `signature` field after the verifier is initially\n * created, or to associate a `sessionId` with an existing verifier.\n *\n * @param args.verifierId - The document ID of the verifier to update.\n * @param args.data - A partial object containing the fields to merge into the verifier document\n *   (e.g. `{ signature: string }` or `{ sessionId: Id<\"Session\"> }`).\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * // Set the PKCE signature on the verifier\n * await ctx.runMutation(\n *   component.identity.verifiers.verifierPatch,\n *   {\n *     verifierId: verifier._id,\n *     data: { signature: generatedSignature },\n *   },\n * );\n * ```\n */\nexport const verifierPatch = mutation({\n  args: { verifierId: v.id(\"AuthVerifier\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { verifierId, data }) => {\n    await ctx.db.patch(\"AuthVerifier\", verifierId, data);\n    return null;\n  },\n});\n\n/**\n * Delete a verifier document permanently.\n *\n * Removes the verifier from the `AuthVerifier` table. This is typically called\n * after a successful OAuth callback to clean up the consumed PKCE state, or\n * to expire stale verifiers that were never completed.\n *\n * @param args.verifierId - The document ID of the verifier to delete.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * // Clean up the verifier after a successful OAuth exchange\n * await ctx.runMutation(\n *   component.identity.verifiers.verifierDelete,\n *   { verifierId: verifier._id },\n * );\n * ```\n */\nexport const verifierDelete = mutation({\n  args: { verifierId: v.id(\"AuthVerifier\") },\n  returns: v.null(),\n  handler: async (ctx, { verifierId }) => {\n    await ctx.db.delete(\"AuthVerifier\", verifierId);\n    return null;\n  },\n});\n\n// ============================================================================\n// Verification Codes\n// ============================================================================\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,MAAa,iBAAiB,SAAS;CACrC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,UAAU,CAAC,EAAE;CAChD,SAAS,EAAE,GAAG,eAAe;CAC7B,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GAAG,OAAO,gBAAgB,EAAa,WAAkB,CAAC;;CAE9E,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBF,MAAa,kBAAkB,MAAM;CACnC,MAAM,EAAE,YAAY,EAAE,GAAG,eAAe,EAAE;CAC1C,SAAS,EAAE,MAAM,kBAAkB,EAAE,MAAM,CAAC;CAC5C,SAAS,OAAO,KAAK,EAAE,iBAAiB;AACtC,SAAO,MAAM,IAAI,GAAG,IAAI,gBAAgB,WAAW;;CAEtD,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,yBAAyB,MAAM;CAC1C,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE;CAC/B,SAAS,EAAE,MAAM,kBAAkB,EAAE,MAAM,CAAC;CAC5C,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GACd,MAAM,eAAe,CACrB,UAAU,cAAc,MAAM,EAAE,GAAG,aAAa,UAAU,CAAC,CAC3D,QAAQ;;CAEd,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BF,MAAa,gBAAgB,SAAS;CACpC,MAAM;EAAE,YAAY,EAAE,GAAG,eAAe;EAAE,MAAM,EAAE,KAAK;EAAE;CACzD,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,YAAY,WAAW;AAC5C,QAAM,IAAI,GAAG,MAAM,gBAAgB,YAAY,KAAK;AACpD,SAAO;;CAEV,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,iBAAiB,SAAS;CACrC,MAAM,EAAE,YAAY,EAAE,GAAG,eAAe,EAAE;CAC1C,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,iBAAiB;AACtC,QAAM,IAAI,GAAG,OAAO,gBAAgB,WAAW;AAC/C,SAAO;;CAEV,CAAC"}