@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

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

@@ -1,147 +0,0 @@
-declare namespace accounts_d_exports {
-  export { accountDelete, accountGet, accountGetById, accountInsert, accountListByUser, accountPatch };
-}
-/**
- * List all accounts linked to a specific user.
- *
- * Queries the `Account` table using the `user_id_provider` index to efficiently
- * retrieve every authentication account (e.g. OAuth, credentials, email) that
- * belongs to the given user.
- *
- * @param args.userId - The document ID of the user whose accounts should be retrieved.
- * @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}`);
- * }
- * ```
- */
-declare const accountListByUser: any;
-/**
- * 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}`);
- * }
- * ```
- */
-declare const accountGet: any;
-/**
- * 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}`);
- * }
- * ```
- */
-declare const accountGetById: any;
-/**
- * Create a new account that links a user to an authentication provider.
- *
- * Inserts a row into the `Account` table, establishing the relationship between
- * a user document and an external authentication provider (OAuth, credentials,
- * email/phone OTP, etc.). A single user may have multiple accounts for different
- * providers.
- *
- * @param args.userId - The document ID of the user to link this account to.
- * @param args.provider - The name of the authentication provider (e.g. `"google"`, `"credentials"`).
- * @param args.providerAccountId - The unique identifier for this user within the external provider.
- * @param args.secret - An optional hashed secret (e.g. password hash) stored for credential-based providers.
- * @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,
- *   },
- * );
- * ```
- */
-declare const accountInsert: any;
-/**
- * Patch an existing account document with partial data.
- *
- * Merges the provided fields into the existing account document. Fields not
- * included in `data` are left unchanged. This is useful for updating a stored
- * secret (e.g. after a password change) or modifying extended metadata.
- *
- * @param args.accountId - The document ID of the account to update.
- * @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 },
- *   },
- * );
- * ```
- */
-declare const accountPatch: any;
-/**
- * Delete an account document permanently.
- *
- * Removes the account from the `Account` table. This effectively unlinks the
- * user from the corresponding authentication provider. Callers should ensure
- * that related resources (verification codes, sessions, etc.) are cleaned up
- * separately if needed.
- *
- * @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 },
- * );
- * ```
- */
-declare const accountDelete: any;
-//#endregion
-export { accountDelete, accountGet, accountGetById, accountInsert, accountListByUser, accountPatch, accounts_d_exports };
-//# sourceMappingURL=accounts.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"accounts.d.ts","names":[],"sources":["../../../../src/component/public/identity/accounts.ts"],"mappings":";;;;;;;;;;;;;;AA2BA;;;;;AAmCA;;;;;AAiCA;cApEa,iBAAA;;;;AAwGb;;;;;AAoCA;;;;;AA4BA;;;;;;;;;;;cArIa,UAAA;;;;;;;;;;;;;;;;;;;;;cAiCA,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoCA,aAAA;;;;;;;;;;;;;;;;;;;;;;;cAoCA,YAAA;;;;;;;;;;;;;;;;;;;;cA4BA,aAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"accounts.js","names":[],"sources":["../../../../src/component/public/identity/accounts.ts"],"sourcesContent":["import { v } from \"convex/values\";\n\nimport { mutation, query } from \"../../functions\";\nimport { vAccountDoc } from \"../../model\";\n\n/**\n * List all accounts linked to a specific user.\n *\n * Queries the `Account` table using the `user_id_provider` index to efficiently\n * retrieve every authentication account (e.g. OAuth, credentials, email) that\n * belongs to the given user.\n *\n * @param args.userId - The document ID of the user whose accounts should be retrieved.\n * @returns An array of account documents associated with the user. Each document\n *   includes fields such as `provider`, `providerAccountId`, `secret`, and `extend`.\n *\n * @example\n * ```ts\n * const accounts = await ctx.runQuery(\n *   component.identity.accounts.accountListByUser,\n *   { userId: user._id },\n * );\n * for (const account of accounts) {\n *   console.log(`Provider: ${account.provider}, ID: ${account.providerAccountId}`);\n * }\n * ```\n */\nexport const accountListByUser = query({\n  args: { userId: v.id(\"User\") },\n  returns: v.array(vAccountDoc),\n  handler: async (ctx, { userId }) => {\n    return await ctx.db\n      .query(\"Account\")\n      .withIndex(\"user_id_provider\", (q) => q.eq(\"userId\", userId as any))\n      .collect();\n  },\n});\n\n/**\n * Look up an account by its provider name and provider-specific account ID.\n *\n * Uses the `provider_account_id` index to find the unique account that matches\n * the given provider and external account identifier. This is the primary way\n * to resolve an incoming authentication event (e.g. an OAuth callback) to an\n * existing account in the system.\n *\n * @param args.provider - The name of the authentication provider (e.g. `\"google\"`, `\"github\"`, `\"credentials\"`).\n * @param args.providerAccountId - The unique identifier assigned to the user by the external provider.\n * @returns The matching account document, or `null` if no account exists for the\n *   given provider and provider account ID combination.\n *\n * @example\n * ```ts\n * const account = await ctx.runQuery(\n *   component.identity.accounts.accountGet,\n *   { provider: \"google\", providerAccountId: \"1184210396400123\" },\n * );\n * if (account !== null) {\n *   console.log(`Found account for user: ${account.userId}`);\n * }\n * ```\n */\nexport const accountGet = query({\n  args: { provider: v.string(), providerAccountId: v.string() },\n  returns: v.union(vAccountDoc, v.null()),\n  handler: async (ctx, { provider, providerAccountId }) => {\n    return await ctx.db\n      .query(\"Account\")\n      .withIndex(\"provider_account_id\", (q) =>\n        q.eq(\"provider\", provider).eq(\"providerAccountId\", providerAccountId),\n      )\n      .unique();\n  },\n});\n\n/**\n * Retrieve a single account by its Convex document ID.\n *\n * Performs a direct point lookup on the `Account` table. Returns `null` if the\n * document has been deleted or never existed.\n *\n * @param args.accountId - The Convex document ID (`Id<\"Account\">`) of the account to retrieve.\n * @returns The account document if it exists, or `null` otherwise.\n *\n * @example\n * ```ts\n * const account = await ctx.runQuery(\n *   component.identity.accounts.accountGetById,\n *   { accountId: existingAccountId },\n * );\n * if (account !== null) {\n *   console.log(`Provider: ${account.provider}`);\n * }\n * ```\n */\nexport const accountGetById = query({\n  args: { accountId: v.id(\"Account\") },\n  returns: v.union(vAccountDoc, v.null()),\n  handler: async (ctx, { accountId }) => {\n    return await ctx.db.get(\"Account\", accountId);\n  },\n});\n\n/**\n * Create a new account that links a user to an authentication provider.\n *\n * Inserts a row into the `Account` table, establishing the relationship between\n * a user document and an external authentication provider (OAuth, credentials,\n * email/phone OTP, etc.). A single user may have multiple accounts for different\n * providers.\n *\n * @param args.userId - The document ID of the user to link this account to.\n * @param args.provider - The name of the authentication provider (e.g. `\"google\"`, `\"credentials\"`).\n * @param args.providerAccountId - The unique identifier for this user within the external provider.\n * @param args.secret - An optional hashed secret (e.g. password hash) stored for credential-based providers.\n * @param args.extend - Optional arbitrary data to store alongside the account for application-specific needs.\n * @returns The document ID of the newly created account.\n *\n * @example\n * ```ts\n * const accountId = await ctx.runMutation(\n *   component.identity.accounts.accountInsert,\n *   {\n *     userId: user._id,\n *     provider: \"credentials\",\n *     providerAccountId: \"user@example.com\",\n *     secret: hashedPassword,\n *   },\n * );\n * ```\n */\nexport const accountInsert = mutation({\n  args: {\n    userId: v.id(\"User\"),\n    provider: v.string(),\n    providerAccountId: v.string(),\n    secret: v.optional(v.string()),\n    extend: v.optional(v.any()),\n  },\n  returns: v.id(\"Account\"),\n  handler: async (ctx, args) => {\n    return await ctx.db.insert(\"Account\", args as any);\n  },\n});\n\n/**\n * Patch an existing account document with partial data.\n *\n * Merges the provided fields into the existing account document. Fields not\n * included in `data` are left unchanged. This is useful for updating a stored\n * secret (e.g. after a password change) or modifying extended metadata.\n *\n * @param args.accountId - The document ID of the account to update.\n * @param args.data - A partial object containing the fields to merge into the account document.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   component.identity.accounts.accountPatch,\n *   {\n *     accountId: account._id,\n *     data: { secret: newHashedPassword },\n *   },\n * );\n * ```\n */\nexport const accountPatch = mutation({\n  args: { accountId: v.id(\"Account\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { accountId, data }) => {\n    await ctx.db.patch(\"Account\", accountId, data);\n    return null;\n  },\n});\n\n/**\n * Delete an account document permanently.\n *\n * Removes the account from the `Account` table. This effectively unlinks the\n * user from the corresponding authentication provider. Callers should ensure\n * that related resources (verification codes, sessions, etc.) are cleaned up\n * separately if needed.\n *\n * @param args.accountId - The document ID of the account to delete.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * await ctx.runMutation(\n *   component.identity.accounts.accountDelete,\n *   { accountId: account._id },\n * );\n * ```\n */\nexport const accountDelete = mutation({\n  args: { accountId: v.id(\"Account\") },\n  returns: v.null(),\n  handler: async (ctx, { accountId }) => {\n    await ctx.db.delete(\"Account\", accountId);\n    return null;\n  },\n});\n\n// ============================================================================\n// Sessions\n// ============================================================================\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,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,qBAAqB,MAAM,EAAE,GAAG,UAAU,OAAc,CAAC,CACnE,SAAS;;CAEf,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BF,MAAa,aAAa,MAAM;CAC9B,MAAM;EAAE,UAAU,EAAE,QAAQ;EAAE,mBAAmB,EAAE,QAAQ;EAAE;CAC7D,SAAS,EAAE,MAAM,aAAa,EAAE,MAAM,CAAC;CACvC,SAAS,OAAO,KAAK,EAAE,UAAU,wBAAwB;AACvD,SAAO,MAAM,IAAI,GACd,MAAM,UAAU,CAChB,UAAU,wBAAwB,MACjC,EAAE,GAAG,YAAY,SAAS,CAAC,GAAG,qBAAqB,kBAAkB,CACtE,CACA,QAAQ;;CAEd,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BF,MAAa,gBAAgB,SAAS;CACpC,MAAM;EACJ,QAAQ,EAAE,GAAG,OAAO;EACpB,UAAU,EAAE,QAAQ;EACpB,mBAAmB,EAAE,QAAQ;EAC7B,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;EAC9B,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC;EAC5B;CACD,SAAS,EAAE,GAAG,UAAU;CACxB,SAAS,OAAO,KAAK,SAAS;AAC5B,SAAO,MAAM,IAAI,GAAG,OAAO,WAAW,KAAY;;CAErD,CAAC;;;;;;;;;;;;;;;;;;;;;;;AAwBF,MAAa,eAAe,SAAS;CACnC,MAAM;EAAE,WAAW,EAAE,GAAG,UAAU;EAAE,MAAM,EAAE,KAAK;EAAE;CACnD,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,WAAW,WAAW;AAC3C,QAAM,IAAI,GAAG,MAAM,WAAW,WAAW,KAAK;AAC9C,SAAO;;CAEV,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,gBAAgB,SAAS;CACpC,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,QAAM,IAAI,GAAG,OAAO,WAAW,UAAU;AACzC,SAAO;;CAEV,CAAC"}

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

@@ -1,104 +0,0 @@
-declare namespace codes_d_exports {
-  export { verificationCodeCreate, verificationCodeDelete, verificationCodeGetByAccountId, verificationCodeGetByCode };
-}
-/**
- * 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");
- * }
- * ```
- */
-declare const verificationCodeGetByAccountId: any;
-/**
- * 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}`);
- * }
- * ```
- */
-declare const verificationCodeGetByCode: any;
-/**
- * Create a new verification code for OTP, magic link, or OAuth flows.
- *
- * Inserts a document into the `VerificationCode` table that ties a short-lived
- * code to a specific account and provider. The code can be used for email OTP,
- * phone OTP, magic link, or OAuth state verification depending on the flow.
- *
- * @param args.accountId - The document ID of the account this verification code is associated with.
- * @param args.provider - The name of the authentication provider initiating the verification
- *   (e.g. `"resend-otp"`, `"twilio-otp"`, `"google"`).
- * @param args.code - The verification code string (e.g. a random OTP or an opaque token for magic links).
- * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this code expires.
- * @param args.verifier - An optional PKCE verifier string used in OAuth/OIDC flows to prevent CSRF attacks.
- * @param args.emailVerified - An optional email address that will be marked as verified upon successful
- *   code redemption.
- * @param args.phoneVerified - An optional phone number that will be marked as verified upon successful
- *   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",
- *   },
- * );
- * ```
- */
-declare const verificationCodeCreate: any;
-/**
- * Delete a verification code document permanently.
- *
- * Removes the verification code from the `VerificationCode` table. This is
- * typically called after the code has been successfully redeemed or when it
- * needs to be invalidated (e.g. replaced by a new code).
- *
- * @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 },
- * );
- * ```
- */
-declare const verificationCodeDelete: any;
-//#endregion
-export { codes_d_exports, verificationCodeCreate, verificationCodeDelete, verificationCodeGetByAccountId, verificationCodeGetByCode };
-//# sourceMappingURL=codes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"codes.d.ts","names":[],"sources":["../../../../src/component/public/identity/codes.ts"],"mappings":";;;;;;;;;;;;AA0BA;;;;;AAgCA;;;;;AA4CA;;cA5Ea,8BAAA;;;AA+Gb;;;;;;;;;;;;;;;;;;;cA/Ea,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4CA,sBAAA;;;;;;;;;;;;;;;;;;;;cAmCA,sBAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"codes.js","names":[],"sources":["../../../../src/component/public/identity/codes.ts"],"sourcesContent":["import { v } from \"convex/values\";\n\nimport { mutation, query } from \"../../functions\";\nimport { vVerificationCodeDoc } from \"../../model\";\n\n/**\n * Find a verification code by its associated account ID.\n *\n * Queries the `VerificationCode` table using the `account_id` index to locate\n * the unique verification code linked to the given account. Each account has at\n * most one active verification code at a time.\n *\n * @param args.accountId - The document ID of the account whose verification code should be retrieved.\n * @returns The verification code document if one exists for the account, or `null` otherwise.\n *\n * @example\n * ```ts\n * const code = await ctx.runQuery(\n *   component.identity.codes.verificationCodeGetByAccountId,\n *   { accountId: account._id },\n * );\n * if (code !== null && code.expirationTime > Date.now()) {\n *   console.log(\"Active verification code exists\");\n * }\n * ```\n */\nexport const verificationCodeGetByAccountId = query({\n  args: { accountId: v.id(\"Account\") },\n  returns: v.union(vVerificationCodeDoc, v.null()),\n  handler: async (ctx, { accountId }) => {\n    return await ctx.db\n      .query(\"VerificationCode\")\n      .withIndex(\"account_id\", (q) => q.eq(\"accountId\", accountId as any))\n      .unique();\n  },\n});\n\n/**\n * Find a verification code by its code string value.\n *\n * Queries the `VerificationCode` table using the `code` index to locate the\n * unique verification code document matching the given code string. This is\n * the primary lookup used when a user submits an OTP or clicks a magic link.\n *\n * @param args.code - The verification code string to look up (e.g. a 6-digit OTP or a magic-link token).\n * @returns The verification code document if a match is found, or `null` otherwise.\n *\n * @example\n * ```ts\n * const codeDoc = await ctx.runQuery(\n *   component.identity.codes.verificationCodeGetByCode,\n *   { code: \"482910\" },\n * );\n * if (codeDoc !== null && codeDoc.expirationTime > Date.now()) {\n *   console.log(`Code is valid for account: ${codeDoc.accountId}`);\n * }\n * ```\n */\nexport const verificationCodeGetByCode = query({\n  args: { code: v.string() },\n  returns: v.union(vVerificationCodeDoc, v.null()),\n  handler: async (ctx, { code }) => {\n    return await ctx.db\n      .query(\"VerificationCode\")\n      .withIndex(\"code\", (q) => q.eq(\"code\", code))\n      .unique();\n  },\n});\n\n/**\n * Create a new verification code for OTP, magic link, or OAuth flows.\n *\n * Inserts a document into the `VerificationCode` table that ties a short-lived\n * code to a specific account and provider. The code can be used for email OTP,\n * phone OTP, magic link, or OAuth state verification depending on the flow.\n *\n * @param args.accountId - The document ID of the account this verification code is associated with.\n * @param args.provider - The name of the authentication provider initiating the verification\n *   (e.g. `\"resend-otp\"`, `\"twilio-otp\"`, `\"google\"`).\n * @param args.code - The verification code string (e.g. a random OTP or an opaque token for magic links).\n * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this code expires.\n * @param args.verifier - An optional PKCE verifier string used in OAuth/OIDC flows to prevent CSRF attacks.\n * @param args.emailVerified - An optional email address that will be marked as verified upon successful\n *   code redemption.\n * @param args.phoneVerified - An optional phone number that will be marked as verified upon successful\n *   code redemption.\n * @returns The document ID of the newly created verification code.\n *\n * @example\n * ```ts\n * const codeId = await ctx.runMutation(\n *   component.identity.codes.verificationCodeCreate,\n *   {\n *     accountId: account._id,\n *     provider: \"resend-otp\",\n *     code: \"482910\",\n *     expirationTime: Date.now() + 10 * 60 * 1000, // 10 minutes\n *     emailVerified: \"alice@example.com\",\n *   },\n * );\n * ```\n */\nexport const verificationCodeCreate = mutation({\n  args: {\n    accountId: v.id(\"Account\"),\n    provider: v.string(),\n    code: v.string(),\n    expirationTime: v.number(),\n    verifier: v.optional(v.string()),\n    emailVerified: v.optional(v.string()),\n    phoneVerified: v.optional(v.string()),\n  },\n  returns: v.id(\"VerificationCode\"),\n  handler: async (ctx, args) => {\n    return await ctx.db.insert(\"VerificationCode\", args as any);\n  },\n});\n\n/**\n * Delete a verification code document permanently.\n *\n * Removes the verification code from the `VerificationCode` table. This is\n * typically called after the code has been successfully redeemed or when it\n * needs to be invalidated (e.g. replaced by a new code).\n *\n * @param args.verificationCodeId - The document ID of the verification code to delete.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * // Delete the code after successful verification\n * await ctx.runMutation(\n *   component.identity.codes.verificationCodeDelete,\n *   { verificationCodeId: codeDoc._id },\n * );\n * ```\n */\nexport const verificationCodeDelete = mutation({\n  args: { verificationCodeId: v.id(\"VerificationCode\") },\n  returns: v.null(),\n  handler: async (ctx, { verificationCodeId }) => {\n    await ctx.db.delete(\"VerificationCode\", verificationCodeId);\n    return null;\n  },\n});\n\n// ============================================================================\n// Refresh Tokens\n// ============================================================================\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,iCAAiC,MAAM;CAClD,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM,sBAAsB,EAAE,MAAM,CAAC;CAChD,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GACd,MAAM,mBAAmB,CACzB,UAAU,eAAe,MAAM,EAAE,GAAG,aAAa,UAAiB,CAAC,CACnE,QAAQ;;CAEd,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuBF,MAAa,4BAA4B,MAAM;CAC7C,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE;CAC1B,SAAS,EAAE,MAAM,sBAAsB,EAAE,MAAM,CAAC;CAChD,SAAS,OAAO,KAAK,EAAE,WAAW;AAChC,SAAO,MAAM,IAAI,GACd,MAAM,mBAAmB,CACzB,UAAU,SAAS,MAAM,EAAE,GAAG,QAAQ,KAAK,CAAC,CAC5C,QAAQ;;CAEd,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCF,MAAa,yBAAyB,SAAS;CAC7C,MAAM;EACJ,WAAW,EAAE,GAAG,UAAU;EAC1B,UAAU,EAAE,QAAQ;EACpB,MAAM,EAAE,QAAQ;EAChB,gBAAgB,EAAE,QAAQ;EAC1B,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC;EAChC,eAAe,EAAE,SAAS,EAAE,QAAQ,CAAC;EACrC,eAAe,EAAE,SAAS,EAAE,QAAQ,CAAC;EACtC;CACD,SAAS,EAAE,GAAG,mBAAmB;CACjC,SAAS,OAAO,KAAK,SAAS;AAC5B,SAAO,MAAM,IAAI,GAAG,OAAO,oBAAoB,KAAY;;CAE9D,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,yBAAyB,SAAS;CAC7C,MAAM,EAAE,oBAAoB,EAAE,GAAG,mBAAmB,EAAE;CACtD,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,yBAAyB;AAC9C,QAAM,IAAI,GAAG,OAAO,oBAAoB,mBAAmB;AAC3D,SAAO;;CAEV,CAAC"}

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

@@ -1,128 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"sessions.js","names":[],"sources":["../../../../src/component/public/identity/sessions.ts"],"sourcesContent":["import { v } from \"convex/values\";\n\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,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

@@ -1,169 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.js","names":[],"sources":["../../../../src/component/public/identity/tokens.ts"],"sourcesContent":["import { v } from \"convex/values\";\n\nimport { mutation, query } from \"../../functions\";\nimport { vRefreshTokenDoc } from \"../../model\";\n\n/**\n * Create a new refresh token for a session.\n *\n * Inserts a document into the `RefreshToken` table. Refresh tokens are used to\n * obtain new access tokens without requiring the user to re-authenticate. When\n * a refresh token is rotated, the new token references the old one via\n * `parentRefreshTokenId` to form a token chain for replay detection.\n *\n * @param args.sessionId - The document ID of the session this refresh token belongs to.\n * @param args.expirationTime - The Unix timestamp (in milliseconds) at which this refresh token expires.\n * @param args.parentRefreshTokenId - The document ID of the parent refresh token that was\n *   exchanged to create this one. Omitted for the initial token in a session.\n * @returns The document ID of the newly created refresh token.\n *\n * @example\n * ```ts\n * const tokenId = await ctx.runMutation(\n *   component.identity.tokens.refreshTokenCreate,\n *   {\n *     sessionId: session._id,\n *     expirationTime: Date.now() + 7 * 24 * 60 * 60 * 1000, // 7 days\n *   },\n * );\n * ```\n */\nexport const refreshTokenCreate = mutation({\n  args: {\n    sessionId: v.id(\"Session\"),\n    expirationTime: v.number(),\n    parentRefreshTokenId: v.optional(v.id(\"RefreshToken\")),\n  },\n  returns: v.id(\"RefreshToken\"),\n  handler: async (ctx, args) => {\n    return await ctx.db.insert(\"RefreshToken\", args as any);\n  },\n});\n\n/**\n * Retrieve a single refresh token by its Convex document ID.\n *\n * Performs a direct point lookup on the `RefreshToken` table. Returns `null` if\n * the token has been deleted or never existed.\n *\n * @param args.refreshTokenId - The Convex document ID (`Id<\"RefreshToken\">`) of the token to retrieve.\n * @returns The refresh token document if it exists, or `null` otherwise.\n *\n * @example\n * ```ts\n * const token = await ctx.runQuery(\n *   component.identity.tokens.refreshTokenGetById,\n *   { refreshTokenId: storedTokenId },\n * );\n * if (token !== null && token.expirationTime > Date.now()) {\n *   console.log(\"Refresh token is still valid\");\n * }\n * ```\n */\nexport const refreshTokenGetById = query({\n  args: { refreshTokenId: v.id(\"RefreshToken\") },\n  returns: v.union(vRefreshTokenDoc, v.null()),\n  handler: async (ctx, { refreshTokenId }) => {\n    return await ctx.db.get(\"RefreshToken\", refreshTokenId);\n  },\n});\n\n/**\n * Patch a refresh token document with partial data.\n *\n * Merges the provided fields into the existing refresh token document. This is\n * primarily used to record `firstUsedTime` when a refresh token is first\n * exchanged, marking it as consumed for replay detection.\n *\n * @param args.refreshTokenId - The document ID of the refresh token to update.\n * @param args.data - A partial object containing the fields to merge (e.g. `{ firstUsedTime: number }`).\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * // Mark the refresh token as used\n * await ctx.runMutation(\n *   component.identity.tokens.refreshTokenPatch,\n *   {\n *     refreshTokenId: token._id,\n *     data: { firstUsedTime: Date.now() },\n *   },\n * );\n * ```\n */\nexport const refreshTokenPatch = mutation({\n  args: { refreshTokenId: v.id(\"RefreshToken\"), data: v.any() },\n  returns: v.null(),\n  handler: async (ctx, { refreshTokenId, data }) => {\n    await ctx.db.patch(\"RefreshToken\", refreshTokenId, data);\n    return null;\n  },\n});\n\n/**\n * Get child tokens that were created by exchanging a specific parent token.\n *\n * Queries the `RefreshToken` table using the `session_id_parent_refresh_token_id`\n * index to find all tokens whose `parentRefreshTokenId` matches the provided\n * parent. This is used for replay detection: if a parent token has more than\n * one child, it indicates a potential token reuse attack.\n *\n * @param args.sessionId - The document ID of the session the tokens belong to.\n * @param args.parentRefreshTokenId - The document ID of the parent refresh token whose children to retrieve.\n * @returns An array of refresh token documents that were derived from the specified parent token.\n *\n * @example\n * ```ts\n * const children = await ctx.runQuery(\n *   component.identity.tokens.refreshTokenGetChildren,\n *   {\n *     sessionId: session._id,\n *     parentRefreshTokenId: parentToken._id,\n *   },\n * );\n * if (children.length > 1) {\n *   console.warn(\"Possible token reuse detected!\");\n * }\n * ```\n */\nexport const refreshTokenGetChildren = query({\n  args: {\n    sessionId: v.id(\"Session\"),\n    parentRefreshTokenId: v.id(\"RefreshToken\"),\n  },\n  returns: v.array(vRefreshTokenDoc),\n  handler: async (ctx, { sessionId, parentRefreshTokenId }) => {\n    return await ctx.db\n      .query(\"RefreshToken\")\n      .withIndex(\"session_id_parent_refresh_token_id\", (q) =>\n        q\n          .eq(\"sessionId\", sessionId as any)\n          .eq(\"parentRefreshTokenId\", parentRefreshTokenId as any),\n      )\n      .collect();\n  },\n});\n\n/**\n * List all refresh tokens belonging to a specific session.\n *\n * Queries the `RefreshToken` table using the `session_id_parent_refresh_token_id`\n * index to efficiently retrieve every refresh token associated with the given\n * session, including both active and consumed tokens.\n *\n * @param args.sessionId - The document ID of the session whose refresh tokens should be retrieved.\n * @returns An array of all refresh token documents for the specified session.\n *\n * @example\n * ```ts\n * const tokens = await ctx.runQuery(\n *   component.identity.tokens.refreshTokenListBySession,\n *   { sessionId: session._id },\n * );\n * console.log(`Session has ${tokens.length} refresh token(s)`);\n * ```\n */\nexport const refreshTokenListBySession = query({\n  args: { sessionId: v.id(\"Session\") },\n  returns: v.array(vRefreshTokenDoc),\n  handler: async (ctx, { sessionId }) => {\n    return await ctx.db\n      .query(\"RefreshToken\")\n      .withIndex(\"session_id_parent_refresh_token_id\", (q) =>\n        q.eq(\"sessionId\", sessionId as any),\n      )\n      .collect();\n  },\n});\n\n/**\n * Delete all refresh tokens for a session.\n *\n * Queries the `RefreshToken` table for all tokens belonging to the given session\n * and deletes them in parallel. This is typically called when a session is\n * revoked or when token reuse is detected, effectively invalidating the entire\n * token chain for that session.\n *\n * @param args.sessionId - The document ID of the session whose refresh tokens should be deleted.\n * @returns `null` on success.\n *\n * @example\n * ```ts\n * // Invalidate all tokens for a compromised session\n * await ctx.runMutation(\n *   component.identity.tokens.refreshTokenDeleteAll,\n *   { sessionId: session._id },\n * );\n * ```\n */\nexport const refreshTokenDeleteAll = mutation({\n  args: { sessionId: v.id(\"Session\") },\n  returns: v.null(),\n  handler: async (ctx, { sessionId }) => {\n    const tokens = await ctx.db\n      .query(\"RefreshToken\")\n      .withIndex(\"session_id_parent_refresh_token_id\", (q) =>\n        q.eq(\"sessionId\", sessionId as any),\n      )\n      .collect();\n    await Promise.all(\n      tokens.map((token) => ctx.db.delete(\"RefreshToken\", token._id)),\n    );\n    return null;\n  },\n});\n\n/**\n * Get the active (unused) refresh token for a session.\n *\n * Queries the `RefreshToken` table using the `session_id_first_used` index to\n * find the most recently created token for the session that has not yet been\n * exchanged (i.e. `firstUsedTime` is `undefined`). This represents the current\n * valid refresh token the client should be holding.\n *\n * @param args.sessionId - The document ID of the session whose active refresh token should be retrieved.\n * @returns The most recent unused refresh token document, or `null` if no active token exists\n *   (e.g. all tokens have been consumed or the session has no tokens).\n *\n * @example\n * ```ts\n * const activeToken = await ctx.runQuery(\n *   component.identity.tokens.refreshTokenGetActive,\n *   { sessionId: session._id },\n * );\n * if (activeToken !== null) {\n *   console.log(`Active token expires at: ${activeToken.expirationTime}`);\n * }\n * ```\n */\nexport const refreshTokenGetActive = query({\n  args: { sessionId: v.id(\"Session\") },\n  returns: v.union(vRefreshTokenDoc, v.null()),\n  handler: async (ctx, { sessionId }) => {\n    return await ctx.db\n      .query(\"RefreshToken\")\n      .withIndex(\"session_id_first_used\", (q) =>\n        q.eq(\"sessionId\", sessionId as any).eq(\"firstUsedTime\", undefined),\n      )\n      .order(\"desc\")\n      .first();\n  },\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,qBAAqB,SAAS;CACzC,MAAM;EACJ,WAAW,EAAE,GAAG,UAAU;EAC1B,gBAAgB,EAAE,QAAQ;EAC1B,sBAAsB,EAAE,SAAS,EAAE,GAAG,eAAe,CAAC;EACvD;CACD,SAAS,EAAE,GAAG,eAAe;CAC7B,SAAS,OAAO,KAAK,SAAS;AAC5B,SAAO,MAAM,IAAI,GAAG,OAAO,gBAAgB,KAAY;;CAE1D,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBF,MAAa,sBAAsB,MAAM;CACvC,MAAM,EAAE,gBAAgB,EAAE,GAAG,eAAe,EAAE;CAC9C,SAAS,EAAE,MAAM,kBAAkB,EAAE,MAAM,CAAC;CAC5C,SAAS,OAAO,KAAK,EAAE,qBAAqB;AAC1C,SAAO,MAAM,IAAI,GAAG,IAAI,gBAAgB,eAAe;;CAE1D,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyBF,MAAa,oBAAoB,SAAS;CACxC,MAAM;EAAE,gBAAgB,EAAE,GAAG,eAAe;EAAE,MAAM,EAAE,KAAK;EAAE;CAC7D,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,gBAAgB,WAAW;AAChD,QAAM,IAAI,GAAG,MAAM,gBAAgB,gBAAgB,KAAK;AACxD,SAAO;;CAEV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BF,MAAa,0BAA0B,MAAM;CAC3C,MAAM;EACJ,WAAW,EAAE,GAAG,UAAU;EAC1B,sBAAsB,EAAE,GAAG,eAAe;EAC3C;CACD,SAAS,EAAE,MAAM,iBAAiB;CAClC,SAAS,OAAO,KAAK,EAAE,WAAW,2BAA2B;AAC3D,SAAO,MAAM,IAAI,GACd,MAAM,eAAe,CACrB,UAAU,uCAAuC,MAChD,EACG,GAAG,aAAa,UAAiB,CACjC,GAAG,wBAAwB,qBAA4B,CAC3D,CACA,SAAS;;CAEf,CAAC;;;;;;;;;;;;;;;;;;;;AAqBF,MAAa,4BAA4B,MAAM;CAC7C,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM,iBAAiB;CAClC,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GACd,MAAM,eAAe,CACrB,UAAU,uCAAuC,MAChD,EAAE,GAAG,aAAa,UAAiB,CACpC,CACA,SAAS;;CAEf,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBF,MAAa,wBAAwB,SAAS;CAC5C,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM;CACjB,SAAS,OAAO,KAAK,EAAE,gBAAgB;EACrC,MAAM,SAAS,MAAM,IAAI,GACtB,MAAM,eAAe,CACrB,UAAU,uCAAuC,MAChD,EAAE,GAAG,aAAa,UAAiB,CACpC,CACA,SAAS;AACZ,QAAM,QAAQ,IACZ,OAAO,KAAK,UAAU,IAAI,GAAG,OAAO,gBAAgB,MAAM,IAAI,CAAC,CAChE;AACD,SAAO;;CAEV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;AAyBF,MAAa,wBAAwB,MAAM;CACzC,MAAM,EAAE,WAAW,EAAE,GAAG,UAAU,EAAE;CACpC,SAAS,EAAE,MAAM,kBAAkB,EAAE,MAAM,CAAC;CAC5C,SAAS,OAAO,KAAK,EAAE,gBAAgB;AACrC,SAAO,MAAM,IAAI,GACd,MAAM,eAAe,CACrB,UAAU,0BAA0B,MACnC,EAAE,GAAG,aAAa,UAAiB,CAAC,GAAG,iBAAiB,OAAU,CACnE,CACA,MAAM,OAAO,CACb,OAAO;;CAEb,CAAC"}