@robelest/convex-auth 0.0.4-preview.32 → 0.0.4-preview.34

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

@@ -14,18 +14,8 @@ import { ConvexError, v } from "convex/values";
 * @returns An array of account documents associated with the user. Each document
 *   includes fields such as `provider`, `providerAccountId`, `secret`, and `extend`.
 *
-* @example
-* ```ts
-* const accounts = await ctx.runQuery(
-*   component.identity.accounts.accountListByUser,
-*   { userId: user._id },
-* );
-* for (const account of accounts) {
-*   console.log(`Provider: ${account.provider}, ID: ${account.providerAccountId}`);
-* }
-* ```
 */
-const accountListByUser = query({
+const accountList = query({
 	args: { userId: v.id("User") },
 	returns: v.array(vAccountDoc),
 	handler: async (ctx, { userId }) => {
@@ -33,64 +23,21 @@ const accountListByUser = query({
 	}
 });
 /**
-* Look up an account by its provider name and provider-specific account ID.
-*
-* Uses the `provider_account_id` index to find the unique account that matches
-* the given provider and external account identifier. This is the primary way
-* to resolve an incoming authentication event (e.g. an OAuth callback) to an
-* existing account in the system.
-*
-* @param args.provider - The name of the authentication provider (e.g. `"google"`, `"github"`, `"credentials"`).
-* @param args.providerAccountId - The unique identifier assigned to the user by the external provider.
-* @returns The matching account document, or `null` if no account exists for the
-*   given provider and provider account ID combination.
-*
-* @example
-* ```ts
-* const account = await ctx.runQuery(
-*   component.identity.accounts.accountGet,
-*   { provider: "google", providerAccountId: "1184210396400123" },
-* );
-* if (account !== null) {
-*   console.log(`Found account for user: ${account.userId}`);
-* }
-* ```
+* Read an account by identity — one function, all-optional args, unioned
+* return: `{ id }` (point lookup) or `{ provider, providerAccountId }`
+* (unique provider index).
 */
 const accountGet = query({
 	args: {
-		provider: v.string(),
-		providerAccountId: v.string()
+		id: v.optional(v.id("Account")),
+		provider: v.optional(v.string()),
+		providerAccountId: v.optional(v.string())
 	},
 	returns: v.union(vAccountDoc, v.null()),
-	handler: async (ctx, { provider, providerAccountId }) => {
-		return await ctx.db.query("Account").withIndex("provider_account_id", (q) => q.eq("provider", provider).eq("providerAccountId", providerAccountId)).unique();
-	}
-});
-/**
-* Retrieve a single account by its Convex document ID.
-*
-* Performs a direct point lookup on the `Account` table. Returns `null` if the
-* document has been deleted or never existed.
-*
-* @param args.accountId - The Convex document ID (`Id<"Account">`) of the account to retrieve.
-* @returns The account document if it exists, or `null` otherwise.
-*
-* @example
-* ```ts
-* const account = await ctx.runQuery(
-*   component.identity.accounts.accountGetById,
-*   { accountId: existingAccountId },
-* );
-* if (account !== null) {
-*   console.log(`Provider: ${account.provider}`);
-* }
-* ```
-*/
-const accountGetById = query({
-	args: { accountId: v.id("Account") },
-	returns: v.union(vAccountDoc, v.null()),
-	handler: async (ctx, { accountId }) => {
-		return await ctx.db.get("Account", accountId);
+	handler: async (ctx, args) => {
+		if (args.provider !== void 0 && args.providerAccountId !== void 0) return await ctx.db.query("Account").withIndex("provider_account_id", (q) => q.eq("provider", args.provider).eq("providerAccountId", args.providerAccountId)).unique();
+		if (args.id === void 0) return null;
+		return await ctx.db.get("Account", args.id);
 	}
 });
 /**
@@ -108,18 +55,6 @@ const accountGetById = query({
 * @param args.extend - Optional arbitrary data to store alongside the account for application-specific needs.
 * @returns The document ID of the newly created account.
 *
-* @example
-* ```ts
-* const accountId = await ctx.runMutation(
-*   component.identity.accounts.accountInsert,
-*   {
-*     userId: user._id,
-*     provider: "credentials",
-*     providerAccountId: "user@example.com",
-*     secret: hashedPassword,
-*   },
-* );
-* ```
 */
 const accountInsert = mutation({
 	args: {
@@ -145,16 +80,6 @@ const accountInsert = mutation({
 * @param args.data - A partial object containing the fields to merge into the account document.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   component.identity.accounts.accountPatch,
-*   {
-*     accountId: account._id,
-*     data: { secret: newHashedPassword },
-*   },
-* );
-* ```
 */
 const accountPatch = mutation({
 	args: {
@@ -178,13 +103,6 @@ const accountPatch = mutation({
 * @param args.accountId - The document ID of the account to delete.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   component.identity.accounts.accountDelete,
-*   { accountId: account._id },
-* );
-* ```
 */
 const accountDelete = mutation({
 	args: {
@@ -215,5 +133,5 @@ const accountDelete = mutation({
 });
 
 //#endregion
-export { accountDelete, accountGet, accountGetById, accountInsert, accountListByUser, accountPatch };
+export { accountDelete, accountGet, accountInsert, accountList, accountPatch };
 //# sourceMappingURL=accounts.js.map

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

@@ -4,59 +4,20 @@ import { v } from "convex/values";
 
 //#region src/component/public/identity/codes.ts
 /**
-* Find a verification code by its associated account ID.
-*
-* Queries the `VerificationCode` table using the `account_id` index to locate
-* the unique verification code linked to the given account. Each account has at
-* most one active verification code at a time.
-*
-* @param args.accountId - The document ID of the account whose verification code should be retrieved.
-* @returns The verification code document if one exists for the account, or `null` otherwise.
-*
-* @example
-* ```ts
-* const code = await ctx.runQuery(
-*   component.identity.codes.verificationCodeGetByAccountId,
-*   { accountId: account._id },
-* );
-* if (code !== null && code.expirationTime > Date.now()) {
-*   console.log("Active verification code exists");
-* }
-* ```
-*/
-const verificationCodeGetByAccountId = query({
-	args: { accountId: v.id("Account") },
-	returns: v.union(vVerificationCodeDoc, v.null()),
-	handler: async (ctx, { accountId }) => {
-		return await ctx.db.query("VerificationCode").withIndex("account_id", (q) => q.eq("accountId", accountId)).unique();
-	}
-});
-/**
-* Find a verification code by its code string value.
-*
-* Queries the `VerificationCode` table using the `code` index to locate the
-* unique verification code document matching the given code string. This is
-* the primary lookup used when a user submits an OTP or clicks a magic link.
-*
-* @param args.code - The verification code string to look up (e.g. a 6-digit OTP or a magic-link token).
-* @returns The verification code document if a match is found, or `null` otherwise.
-*
-* @example
-* ```ts
-* const codeDoc = await ctx.runQuery(
-*   component.identity.codes.verificationCodeGetByCode,
-*   { code: "482910" },
-* );
-* if (codeDoc !== null && codeDoc.expirationTime > Date.now()) {
-*   console.log(`Code is valid for account: ${codeDoc.accountId}`);
-* }
-* ```
+* Read a verification code by identity — one function, all-optional
+* args, unioned return: `{ accountId }` (unique per account) or
+* `{ code }` (code index).
 */
-const verificationCodeGetByCode = query({
-	args: { code: v.string() },
+const verificationCodeGet = query({
+	args: {
+		accountId: v.optional(v.id("Account")),
+		code: v.optional(v.string())
+	},
 	returns: v.union(vVerificationCodeDoc, v.null()),
-	handler: async (ctx, { code }) => {
-		return await ctx.db.query("VerificationCode").withIndex("code", (q) => q.eq("code", code)).first();
+	handler: async (ctx, args) => {
+		if (args.code !== void 0) return await ctx.db.query("VerificationCode").withIndex("code", (q) => q.eq("code", args.code)).first();
+		if (args.accountId === void 0) return null;
+		return await ctx.db.query("VerificationCode").withIndex("account_id", (q) => q.eq("accountId", args.accountId)).unique();
 	}
 });
 /**
@@ -78,19 +39,6 @@ const verificationCodeGetByCode = query({
 *   code redemption.
 * @returns The document ID of the newly created verification code.
 *
-* @example
-* ```ts
-* const codeId = await ctx.runMutation(
-*   component.identity.codes.verificationCodeCreate,
-*   {
-*     accountId: account._id,
-*     provider: "resend-otp",
-*     code: "482910",
-*     expirationTime: Date.now() + 10 * 60 * 1000, // 10 minutes
-*     emailVerified: "alice@example.com",
-*   },
-* );
-* ```
 */
 const verificationCodeCreate = mutation({
 	args: {
@@ -117,14 +65,6 @@ const verificationCodeCreate = mutation({
 * @param args.verificationCodeId - The document ID of the verification code to delete.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* // Delete the code after successful verification
-* await ctx.runMutation(
-*   component.identity.codes.verificationCodeDelete,
-*   { verificationCodeId: codeDoc._id },
-* );
-* ```
 */
 const verificationCodeDelete = mutation({
 	args: { verificationCodeId: v.id("VerificationCode") },
@@ -136,5 +76,5 @@ const verificationCodeDelete = mutation({
 });
 
 //#endregion
-export { verificationCodeCreate, verificationCodeDelete, verificationCodeGetByAccountId, verificationCodeGetByCode };
+export { verificationCodeCreate, verificationCodeDelete, verificationCodeGet };
 //# sourceMappingURL=codes.js.map

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

@@ -1,70 +1,9 @@
-import { vPaginated, vSessionDoc } from "../../model.js";
+import { vSessionDoc } from "../../model.js";
 import { mutation, query } from "../../functions.js";
 import { v } from "convex/values";
 
 //#region src/component/public/identity/sessions.ts
 /**
-* List sessions with optional filtering and cursor-based pagination.
-*
-* Supports filtering by `userId` to retrieve only sessions belonging to a
-* specific user. When a `userId` filter is provided, the `user_id` index is
-* used for efficient lookup. 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. Currently supports `userId` to
-*   restrict results to sessions for a specific user.
-* @param args.limit - Maximum number of sessions 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.order - Sort direction: `"asc"` or `"desc"` (default `"desc"`).
-* @returns An object with `items` (array of session documents) and `nextCursor`
-*   (`string | null`) for fetching subsequent pages.
-*
-* @example
-* ```ts
-* // List the 10 most recent sessions for a user
-* const page = await ctx.runQuery(
-*   component.identity.sessions.sessionList,
-*   { where: { userId: user._id }, limit: 10, order: "desc" },
-* );
-* for (const session of page.items) {
-*   console.log(`Session ${session._id} expires at ${session.expirationTime}`);
-* }
-* ```
-*/
-const sessionList = query({
-	args: {
-		where: v.optional(v.object({ userId: v.optional(v.id("User")) })),
-		limit: v.optional(v.number()),
-		cursor: v.optional(v.union(v.string(), v.null())),
-		order: v.optional(v.union(v.literal("asc"), v.literal("desc")))
-	},
-	returns: vPaginated(vSessionDoc),
-	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.userId !== void 0) q = ctx.db.query("Session").withIndex("user_id", (idx) => idx.eq("userId", where.userId));
-		else q = ctx.db.query("Session");
-		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
-		};
-	}
-});
-/**
 * Create a new session for a user with a specified expiration time.
 *
 * Inserts a new document into the `Session` table, linking it to the given user.
@@ -75,16 +14,6 @@ const sessionList = query({
 * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this session expires.
 * @returns The document ID of the newly created session.
 *
-* @example
-* ```ts
-* const sessionId = await ctx.runMutation(
-*   component.identity.sessions.sessionCreate,
-*   {
-*     userId: user._id,
-*     expirationTime: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
-*   },
-* );
-* ```
 */
 const sessionCreate = mutation({
 	args: {
@@ -147,16 +76,6 @@ const sessionIssue = mutation({
 * @param args.sessionId - The Convex document ID (`Id<"Session">`) of the session to retrieve.
 * @returns The session document if it exists, or `null` otherwise.
 *
-* @example
-* ```ts
-* const session = await ctx.runQuery(
-*   component.identity.sessions.sessionGetById,
-*   { sessionId: refreshToken.sessionId },
-* );
-* if (session !== null && session.expirationTime > Date.now()) {
-*   console.log("Session is still active");
-* }
-* ```
 */
 const sessionGetById = query({
 	args: { sessionId: v.id("Session") },
@@ -176,18 +95,6 @@ const sessionGetById = query({
 * @param args.sessionId - The document ID of the session to delete.
 * @returns `null` on success (including when the session was already absent).
 *
-* @example
-* ```ts
-* // Revoke a session and its tokens
-* await ctx.runMutation(
-*   component.identity.sessions.sessionDelete,
-*   { sessionId: session._id },
-* );
-* await ctx.runMutation(
-*   component.identity.tokens.refreshTokenDeleteAll,
-*   { sessionId: session._id },
-* );
-* ```
 */
 const sessionDelete = mutation({
 	args: { sessionId: v.id("Session") },
@@ -200,23 +107,14 @@ const sessionDelete = mutation({
 /**
 * List all sessions belonging to a specific user.
 *
-* Queries the `Session` table using the `user_id` index to efficiently retrieve
-* every session document for the given user. Unlike `sessionList`, this returns
-* all matching sessions without pagination.
+* Queries the `Session` table using the `user_id` index to retrieve
+* every session document for the given user, as a flat array.
 *
 * @param args.userId - The document ID of the user whose sessions should be retrieved.
 * @returns An array of session documents for the specified user.
 *
-* @example
-* ```ts
-* const sessions = await ctx.runQuery(
-*   component.identity.sessions.sessionListByUser,
-*   { userId: user._id },
-* );
-* console.log(`User has ${sessions.length} active session(s)`);
-* ```
 */
-const sessionListByUser = query({
+const sessionList = query({
 	args: { userId: v.id("User") },
 	returns: v.array(vSessionDoc),
 	handler: async (ctx, { userId }) => {
@@ -225,5 +123,5 @@ const sessionListByUser = query({
 });
 
 //#endregion
-export { sessionCreate, sessionDelete, sessionGetById, sessionIssue, sessionList, sessionListByUser };
+export { sessionCreate, sessionDelete, sessionGetById, sessionIssue, sessionList };
 //# sourceMappingURL=sessions.js.map

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

@@ -17,16 +17,6 @@ import { v } from "convex/values";
 *   exchanged to create this one. Omitted for the initial token in a session.
 * @returns The document ID of the newly created refresh token.
 *
-* @example
-* ```ts
-* const tokenId = await ctx.runMutation(
-*   component.identity.tokens.refreshTokenCreate,
-*   {
-*     sessionId: session._id,
-*     expirationTime: Date.now() + 7 * 24 * 60 * 60 * 1000, // 7 days
-*   },
-* );
-* ```
 */
 const refreshTokenCreate = mutation({
 	args: {
@@ -40,30 +30,20 @@ const refreshTokenCreate = mutation({
 	}
 });
 /**
-* Retrieve a single refresh token by its Convex document ID.
-*
-* Performs a direct point lookup on the `RefreshToken` table. Returns `null` if
-* the token has been deleted or never existed.
-*
-* @param args.refreshTokenId - The Convex document ID (`Id<"RefreshToken">`) of the token to retrieve.
-* @returns The refresh token document if it exists, or `null` otherwise.
-*
-* @example
-* ```ts
-* const token = await ctx.runQuery(
-*   component.identity.tokens.refreshTokenGetById,
-*   { refreshTokenId: storedTokenId },
-* );
-* if (token !== null && token.expirationTime > Date.now()) {
-*   console.log("Refresh token is still valid");
-* }
-* ```
+* Read a refresh token by identity — one function, all-optional args,
+* unioned return: `{ id }` (point lookup) or `{ activeForSession }`
+* (newest unused token for a session).
 */
-const refreshTokenGetById = query({
-	args: { refreshTokenId: v.id("RefreshToken") },
+const refreshTokenGet = query({
+	args: {
+		id: v.optional(v.id("RefreshToken")),
+		activeForSession: v.optional(v.id("Session"))
+	},
 	returns: v.union(vRefreshTokenDoc, v.null()),
-	handler: async (ctx, { refreshTokenId }) => {
-		return await ctx.db.get("RefreshToken", refreshTokenId);
+	handler: async (ctx, args) => {
+		if (args.activeForSession !== void 0) return await ctx.db.query("RefreshToken").withIndex("session_id_first_used", (q) => q.eq("sessionId", args.activeForSession).eq("firstUsedTime", void 0)).order("desc").first();
+		if (args.id === void 0) return null;
+		return await ctx.db.get("RefreshToken", args.id);
 	}
 });
 /**
@@ -77,17 +57,6 @@ const refreshTokenGetById = query({
 * @param args.data - A partial object containing the fields to merge (e.g. `{ firstUsedTime: number }`).
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* // Mark the refresh token as used
-* await ctx.runMutation(
-*   component.identity.tokens.refreshTokenPatch,
-*   {
-*     refreshTokenId: token._id,
-*     data: { firstUsedTime: Date.now() },
-*   },
-* );
-* ```
 */
 const refreshTokenPatch = mutation({
 	args: {
@@ -112,19 +81,6 @@ const refreshTokenPatch = mutation({
 * @param args.parentRefreshTokenId - The document ID of the parent refresh token whose children to retrieve.
 * @returns An array of refresh token documents that were derived from the specified parent token.
 *
-* @example
-* ```ts
-* const children = await ctx.runQuery(
-*   component.identity.tokens.refreshTokenGetChildren,
-*   {
-*     sessionId: session._id,
-*     parentRefreshTokenId: parentToken._id,
-*   },
-* );
-* if (children.length > 1) {
-*   console.warn("Possible token reuse detected!");
-* }
-* ```
 */
 const refreshTokenGetChildren = query({
 	args: {
@@ -146,14 +102,6 @@ const refreshTokenGetChildren = query({
 * @param args.sessionId - The document ID of the session whose refresh tokens should be retrieved.
 * @returns An array of all refresh token documents for the specified session.
 *
-* @example
-* ```ts
-* const tokens = await ctx.runQuery(
-*   component.identity.tokens.refreshTokenListBySession,
-*   { sessionId: session._id },
-* );
-* console.log(`Session has ${tokens.length} refresh token(s)`);
-* ```
 */
 const refreshTokenListBySession = query({
 	args: { sessionId: v.id("Session") },
@@ -173,14 +121,6 @@ const refreshTokenListBySession = query({
 * @param args.sessionId - The document ID of the session whose refresh tokens should be deleted.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* // Invalidate all tokens for a compromised session
-* await ctx.runMutation(
-*   component.identity.tokens.refreshTokenDeleteAll,
-*   { sessionId: session._id },
-* );
-* ```
 */
 const refreshTokenDeleteAll = mutation({
 	args: { sessionId: v.id("Session") },
@@ -270,37 +210,7 @@ const refreshTokenExchange = mutation({
 		return null;
 	}
 });
-/**
-* Get the active (unused) refresh token for a session.
-*
-* Queries the `RefreshToken` table using the `session_id_first_used` index to
-* find the most recently created token for the session that has not yet been
-* exchanged (i.e. `firstUsedTime` is `undefined`). This represents the current
-* valid refresh token the client should be holding.
-*
-* @param args.sessionId - The document ID of the session whose active refresh token should be retrieved.
-* @returns The most recent unused refresh token document, or `null` if no active token exists
-*   (e.g. all tokens have been consumed or the session has no tokens).
-*
-* @example
-* ```ts
-* const activeToken = await ctx.runQuery(
-*   component.identity.tokens.refreshTokenGetActive,
-*   { sessionId: session._id },
-* );
-* if (activeToken !== null) {
-*   console.log(`Active token expires at: ${activeToken.expirationTime}`);
-* }
-* ```
-*/
-const refreshTokenGetActive = query({
-	args: { sessionId: v.id("Session") },
-	returns: v.union(vRefreshTokenDoc, v.null()),
-	handler: async (ctx, { sessionId }) => {
-		return await ctx.db.query("RefreshToken").withIndex("session_id_first_used", (q) => q.eq("sessionId", sessionId).eq("firstUsedTime", void 0)).order("desc").first();
-	}
-});
 
 //#endregion
-export { refreshTokenCreate, refreshTokenDeleteAll, refreshTokenExchange, refreshTokenGetActive, refreshTokenGetById, refreshTokenGetChildren, refreshTokenListBySession, refreshTokenPatch };
+export { refreshTokenCreate, refreshTokenDeleteAll, refreshTokenExchange, refreshTokenGet, refreshTokenGetChildren, refreshTokenListBySession, refreshTokenPatch };
 //# sourceMappingURL=tokens.js.map