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

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

@@ -0,0 +1,128 @@
+declare namespace sessions_d_exports {
+  export { sessionCreate, sessionDelete, sessionGetById, sessionList, sessionListByUser };
+}
+/**
+ * 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}`);
+ * }
+ * ```
+ */
+declare const sessionList: any;
+/**
+ * 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.
+ * The session represents an active authenticated context and is typically created
+ * after a successful sign-in or token refresh.
+ *
+ * @param args.userId - The document ID of the user this session belongs to.
+ * @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
+ *   },
+ * );
+ * ```
+ */
+declare const sessionCreate: any;
+/**
+ * Retrieve a single session by its Convex document ID.
+ *
+ * Performs a direct point lookup on the `Session` table. Returns `null` if the
+ * session has been deleted or never existed. This does not check whether the
+ * session has expired -- callers should compare `expirationTime` to the current
+ * time if needed.
+ *
+ * @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");
+ * }
+ * ```
+ */
+declare const sessionGetById: any;
+/**
+ * Delete a session document.
+ *
+ * Removes the session from the `Session` table. This is a no-op if the session
+ * does not exist (i.e. was already deleted). Callers should also clean up
+ * related refresh tokens via `refreshTokenDeleteAll` to fully invalidate the
+ * session.
+ *
+ * @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 },
+ * );
+ * ```
+ */
+declare const sessionDelete: any;
+/**
+ * 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.
+ *
+ * @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)`);
+ * ```
+ */
+declare const sessionListByUser: any;
+//#endregion
+export { sessionCreate, sessionDelete, sessionGetById, sessionList, sessionListByUser, sessions_d_exports };
+//# sourceMappingURL=sessions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","names":[],"sources":["../../../../src/component/public/identity/sessions.ts"],"mappings":";;;;;;;;;;;;;AAkCA;;;;;AAkEA;;;;;AAiCA;;;;;AAgCA;;;;;cAnIa,WAAA;;;;;;;;;;;;;;;;;;;;;;;cAkEA,aAAA;;;;;;;;;;;;;;;;;;;;;;;cAiCA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;cAgCA,aAAA;;;;;;;;;;;;;;;;;;;;cA8BA,iBAAA"}

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

@@ -0,0 +1,192 @@
+import { mutation, query } from "../../functions.js";
+import { vPaginated, vSessionDoc } from "../../model.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.
+* The session represents an active authenticated context and is typically created
+* after a successful sign-in or token refresh.
+*
+* @param args.userId - The document ID of the user this session belongs to.
+* @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: {
+		userId: v.id("User"),
+		expirationTime: v.number()
+	},
+	returns: v.id("Session"),
+	handler: async (ctx, { userId, expirationTime }) => {
+		return await ctx.db.insert("Session", {
+			userId,
+			expirationTime
+		});
+	}
+});
+/**
+* Retrieve a single session by its Convex document ID.
+*
+* Performs a direct point lookup on the `Session` table. Returns `null` if the
+* session has been deleted or never existed. This does not check whether the
+* session has expired -- callers should compare `expirationTime` to the current
+* time if needed.
+*
+* @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") },
+	returns: v.union(vSessionDoc, v.null()),
+	handler: async (ctx, { sessionId }) => {
+		return await ctx.db.get("Session", sessionId);
+	}
+});
+/**
+* Delete a session document.
+*
+* Removes the session from the `Session` table. This is a no-op if the session
+* does not exist (i.e. was already deleted). Callers should also clean up
+* related refresh tokens via `refreshTokenDeleteAll` to fully invalidate the
+* session.
+*
+* @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") },
+	returns: v.null(),
+	handler: async (ctx, { sessionId }) => {
+		if (await ctx.db.get("Session", sessionId) !== null) await ctx.db.delete("Session", sessionId);
+		return null;
+	}
+});
+/**
+* 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.
+*
+* @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({
+	args: { userId: v.id("User") },
+	returns: v.array(vSessionDoc),
+	handler: async (ctx, { userId }) => {
+		return await ctx.db.query("Session").withIndex("user_id", (q) => q.eq("userId", userId)).collect();
+	}
+});
+
+//#endregion
+export { sessionCreate, sessionDelete, sessionGetById, sessionList, sessionListByUser };
+//# sourceMappingURL=sessions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.js","names":[],"sources":["../../../../src/component/public/identity/sessions.ts"],"sourcesContent":["import { v } from \"convex/values\";\nimport { mutation, query } from \"../../functions\";\nimport { vPaginated, vSessionDoc } from \"../../model\";\n\n/**\n * List sessions with optional filtering and cursor-based pagination.\n *\n * Supports filtering by `userId` to retrieve only sessions belonging to a\n * specific user. When a `userId` filter is provided, the `user_id` index is\n * used for efficient lookup. Results are returned as a paginated response\n * `{ items, nextCursor }` -- pass `nextCursor` back as `cursor` to fetch the\n * next page, or receive `null` when all results have been exhausted.\n *\n * @param args.where - Optional filter object. Currently supports `userId` to\n *   restrict results to sessions for a specific user.\n * @param args.limit - Maximum number of sessions 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.order - Sort direction: `\"asc\"` or `\"desc\"` (default `\"desc\"`).\n * @returns An object with `items` (array of session documents) and `nextCursor`\n *   (`string | null`) for fetching subsequent pages.\n *\n * @example\n * ```ts\n * // List the 10 most recent sessions for a user\n * const page = await ctx.runQuery(\n *   component.identity.sessions.sessionList,\n *   { where: { userId: user._id }, limit: 10, order: \"desc\" },\n * );\n * for (const session of page.items) {\n *   console.log(`Session ${session._id} expires at ${session.expirationTime}`);\n * }\n * ```\n */\nexport const sessionList = query({\n  args: {\n    where: v.optional(\n      v.object({\n        userId: v.optional(v.id(\"User\")),\n      }),\n    ),\n    limit: v.optional(v.number()),\n    cursor: v.optional(v.union(v.string(), v.null())),\n    order: v.optional(v.union(v.literal(\"asc\"), v.literal(\"desc\"))),\n  },\n  returns: vPaginated(vSessionDoc),\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.userId !== undefined) {\n      q = ctx.db\n        .query(\"Session\")\n        .withIndex(\"user_id\", (idx) => idx.eq(\"userId\", where.userId!));\n    } else {\n      q = ctx.db.query(\"Session\");\n    }\n\n    q = q.order(order);\n\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 * Create a new session for a user with a specified expiration time.\n *\n * Inserts a new document into the `Session` table, linking it to the given user.\n * The session represents an active authenticated context and is typically created\n * after a successful sign-in or token refresh.\n *\n * @param args.userId - The document ID of the user this session belongs to.\n * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this session expires.\n * @returns The document ID of the newly created session.\n *\n * @example\n * ```ts\n * const sessionId = await ctx.runMutation(\n *   component.identity.sessions.sessionCreate,\n *   {\n *     userId: user._id,\n *     expirationTime: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days\n *   },\n * );\n * ```\n */\nexport const sessionCreate = mutation({\n  args: { userId: v.id(\"User\"), expirationTime: v.number() },\n  returns: v.id(\"Session\"),\n  handler: async (ctx, { userId, expirationTime }) => {\n    return await ctx.db.insert(\"Session\", {\n      userId: userId as any,\n      expirationTime,\n    });\n  },\n});\n\n/**\n * Retrieve a single session by its Convex document ID.\n *\n * Performs a direct point lookup on the `Session` table. Returns `null` if the\n * session has been deleted or never existed. This does not check whether the\n * session has expired -- callers should compare `expirationTime` to the current\n * time if needed.\n *\n * @param args.sessionId - The Convex document ID (`Id<\"Session\">`) of the session to retrieve.\n * @returns The session document if it exists, or `null` otherwise.\n *\n * @example\n * ```ts\n * const session = await ctx.runQuery(\n *   component.identity.sessions.sessionGetById,\n *   { sessionId: refreshToken.sessionId },\n * );\n * if (session !== null && session.expirationTime > Date.now()) {\n *   console.log(\"Session is still active\");\n * }\n * ```\n */\nexport const sessionGetById = query({\n  args: { sessionId: v.id(\"Session\") },\n  returns: v.union(vSessionDoc, v.null()),\n  handler: async (ctx, { sessionId }) => {\n    return await ctx.db.get(\"Session\", sessionId);\n  },\n});\n\n/**\n * Delete a session document.\n *\n * Removes the session from the `Session` table. This is a no-op if the session\n * does not exist (i.e. was already deleted). Callers should also clean up\n * related refresh tokens via `refreshTokenDeleteAll` to fully invalidate the\n * session.\n *\n * @param args.sessionId - The document ID of the session to delete.\n * @returns `null` on success (including when the session was already absent).\n *\n * @example\n * ```ts\n * // Revoke a session and its tokens\n * await ctx.runMutation(\n *   component.identity.sessions.sessionDelete,\n *   { sessionId: session._id },\n * );\n * await ctx.runMutation(\n *   component.identity.tokens.refreshTokenDeleteAll,\n *   { sessionId: session._id },\n * );\n * ```\n */\nexport const sessionDelete = mutation({\n  args: { sessionId: v.id(\"Session\") },\n  returns: v.null(),\n  handler: async (ctx, { sessionId }) => {\n    if ((await ctx.db.get(\"Session\", sessionId)) !== null) {\n      await ctx.db.delete(\"Session\", sessionId);\n    }\n    return null;\n  },\n});\n\n/**\n * List all sessions belonging to a specific user.\n *\n * Queries the `Session` table using the `user_id` index to efficiently retrieve\n * every session document for the given user. Unlike `sessionList`, this returns\n * all matching sessions without pagination.\n *\n * @param args.userId - The document ID of the user whose sessions should be retrieved.\n * @returns An array of session documents for the specified user.\n *\n * @example\n * ```ts\n * const sessions = await ctx.runQuery(\n *   component.identity.sessions.sessionListByUser,\n *   { userId: user._id },\n * );\n * console.log(`User has ${sessions.length} active session(s)`);\n * ```\n */\nexport const sessionListByUser = query({\n  args: { userId: v.id(\"User\") },\n  returns: v.array(vSessionDoc),\n  handler: async (ctx, { userId }) => {\n    return await ctx.db\n      .query(\"Session\")\n      .withIndex(\"user_id\", (q) => q.eq(\"userId\", userId as any))\n      .collect();\n  },\n});\n\n// ============================================================================\n// Verifiers\n// ============================================================================\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,cAAc,MAAM;CAC/B,MAAM;EACJ,OAAO,EAAE,SACP,EAAE,OAAO,EACP,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,EACjC,CAAC,CACH;EACD,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC7B,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;EACjD,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,MAAM,EAAE,EAAE,QAAQ,OAAO,CAAC,CAAC;EAChE;CACD,SAAS,WAAW,YAAY;CAChC,SAAS,OAAO,KAAK,SAAS;EAC5B,MAAM,QAAQ,KAAK,SAAS,EAAE;EAC9B,MAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,KAAK,SAAS,IAAI,EAAE,EAAE,IAAI;EAC1D,MAAM,QAAQ,KAAK,SAAS;EAE5B,IAAI;AACJ,MAAI,MAAM,WAAW,OACnB,KAAI,IAAI,GACL,MAAM,UAAU,CAChB,UAAU,YAAY,QAAQ,IAAI,GAAG,UAAU,MAAM,OAAQ,CAAC;MAEjE,KAAI,IAAI,GAAG,MAAM,UAAU;AAG7B,MAAI,EAAE,MAAM,MAAM;EAElB,MAAM,MAAM,MAAM,EAAE,SAAS;EAC7B,IAAI,WAAW;AACf,MAAI,KAAK,QAAQ;GACf,MAAM,YAAY,IAAI,WAAW,QAAQ,IAAI,QAAQ,KAAK,OAAO;AACjE,OAAI,cAAc,GAChB,YAAW,YAAY;;EAG3B,MAAM,OAAO,IAAI,MAAM,UAAU,WAAW,QAAQ,EAAE;EACtD,MAAM,UAAU,KAAK,SAAS;EAC9B,MAAM,QAAQ,UAAU,KAAK,MAAM,GAAG,MAAM,GAAG;AAE/C,SAAO;GAAE;GAAO,YADG,UAAU,MAAM,MAAM,SAAS,GAAG,MAAM;GAC/B;;CAE/B,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,gBAAgB,SAAS;CACpC,MAAM;EAAE,QAAQ,EAAE,GAAG,OAAO;EAAE,gBAAgB,EAAE,QAAQ;EAAE;CAC1D,SAAS,EAAE,GAAG,UAAU;CACxB,SAAS,OAAO,KAAK,EAAE,QAAQ,qBAAqB;AAClD,SAAO,MAAM,IAAI,GAAG,OAAO,WAAW;GAC5B;GACR;GACD,CAAC;;CAEL,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,iBAAiB,MAAM;CAClC,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM,aAAa,EAAE,MAAM,CAAC;CACvC,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GAAG,IAAI,WAAW,UAAU;;CAEhD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BF,MAAa,gBAAgB,SAAS;CACpC,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,MAAK,MAAM,IAAI,GAAG,IAAI,WAAW,UAAU,KAAM,KAC/C,OAAM,IAAI,GAAG,OAAO,WAAW,UAAU;AAE3C,SAAO;;CAEV,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,oBAAoB,MAAM;CACrC,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE;CAC9B,SAAS,EAAE,MAAM,YAAY;CAC7B,SAAS,OAAO,KAAK,EAAE,aAAa;AAClC,SAAO,MAAM,IAAI,GACd,MAAM,UAAU,CAChB,UAAU,YAAY,MAAM,EAAE,GAAG,UAAU,OAAc,CAAC,CAC1D,SAAS;;CAEf,CAAC"}

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

@@ -0,0 +1,169 @@
+declare namespace tokens_d_exports {
+  export { refreshTokenCreate, refreshTokenDeleteAll, refreshTokenGetActive, refreshTokenGetById, refreshTokenGetChildren, refreshTokenListBySession, refreshTokenPatch };
+}
+/**
+ * Create a new refresh token for a session.
+ *
+ * Inserts a document into the `RefreshToken` table. Refresh tokens are used to
+ * obtain new access tokens without requiring the user to re-authenticate. When
+ * a refresh token is rotated, the new token references the old one via
+ * `parentRefreshTokenId` to form a token chain for replay detection.
+ *
+ * @param args.sessionId - The document ID of the session this refresh token belongs to.
+ * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this refresh token expires.
+ * @param args.parentRefreshTokenId - The document ID of the parent refresh token that was
+ *   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
+ *   },
+ * );
+ * ```
+ */
+declare const refreshTokenCreate: any;
+/**
+ * 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");
+ * }
+ * ```
+ */
+declare const refreshTokenGetById: any;
+/**
+ * Patch a refresh token document with partial data.
+ *
+ * Merges the provided fields into the existing refresh token document. This is
+ * primarily used to record `firstUsedTime` when a refresh token is first
+ * exchanged, marking it as consumed for replay detection.
+ *
+ * @param args.refreshTokenId - The document ID of the refresh token to update.
+ * @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() },
+ *   },
+ * );
+ * ```
+ */
+declare const refreshTokenPatch: any;
+/**
+ * Get child tokens that were created by exchanging a specific parent token.
+ *
+ * Queries the `RefreshToken` table using the `session_id_parent_refresh_token_id`
+ * index to find all tokens whose `parentRefreshTokenId` matches the provided
+ * parent. This is used for replay detection: if a parent token has more than
+ * one child, it indicates a potential token reuse attack.
+ *
+ * @param args.sessionId - The document ID of the session the tokens belong to.
+ * @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!");
+ * }
+ * ```
+ */
+declare const refreshTokenGetChildren: any;
+/**
+ * List all refresh tokens belonging to a specific session.
+ *
+ * Queries the `RefreshToken` table using the `session_id_parent_refresh_token_id`
+ * index to efficiently retrieve every refresh token associated with the given
+ * session, including both active and consumed tokens.
+ *
+ * @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)`);
+ * ```
+ */
+declare const refreshTokenListBySession: any;
+/**
+ * Delete all refresh tokens for a session.
+ *
+ * Queries the `RefreshToken` table for all tokens belonging to the given session
+ * and deletes them in parallel. This is typically called when a session is
+ * revoked or when token reuse is detected, effectively invalidating the entire
+ * token chain for that session.
+ *
+ * @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 },
+ * );
+ * ```
+ */
+declare const refreshTokenDeleteAll: any;
+/**
+ * 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}`);
+ * }
+ * ```
+ */
+declare const refreshTokenGetActive: any;
+//#endregion
+export { refreshTokenCreate, refreshTokenDeleteAll, refreshTokenGetActive, refreshTokenGetById, refreshTokenGetChildren, refreshTokenListBySession, refreshTokenPatch, tokens_d_exports };
+//# sourceMappingURL=tokens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","names":[],"sources":["../../../../src/component/public/identity/tokens.ts"],"mappings":";;;;;;;;;;;;;;;AA6BA;;;;;AAgCA;;;;;AA+BA;;;cA/Da,kBAAA;;AAkGb;;;;;AAqCA;;;;;AAiCA;;;;;AAwCA;;;;cAhLa,mBAAA;;;;;;;;;;;;;;;;;;;;;;;;cA+BA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCA,uBAAA;;;;;;;;;;;;;;;;;;;;cAqCA,yBAAA;;;;;;;;;;;;;;;;;;;;;cAiCA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;cAwCA,qBAAA"}