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

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

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

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

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

@@ -0,0 +1,200 @@
+import { mutation, query } from "../../functions.js";
+import { vAccountDoc } from "../../model.js";
+import { v } from "convex/values";
+
+//#region src/component/public/identity/accounts.ts
+/**
+* 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}`);
+* }
+* ```
+*/
+const accountListByUser = query({
+	args: { userId: v.id("User") },
+	returns: v.array(vAccountDoc),
+	handler: async (ctx, { userId }) => {
+		return await ctx.db.query("Account").withIndex("user_id_provider", (q) => q.eq("userId", userId)).collect();
+	}
+});
+/**
+* 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}`);
+* }
+* ```
+*/
+const accountGet = query({
+	args: {
+		provider: v.string(),
+		providerAccountId: 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);
+	}
+});
+/**
+* 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,
+*   },
+* );
+* ```
+*/
+const accountInsert = mutation({
+	args: {
+		userId: v.id("User"),
+		provider: v.string(),
+		providerAccountId: v.string(),
+		secret: v.optional(v.string()),
+		extend: v.optional(v.any())
+	},
+	returns: v.id("Account"),
+	handler: async (ctx, args) => {
+		return await ctx.db.insert("Account", args);
+	}
+});
+/**
+* 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 },
+*   },
+* );
+* ```
+*/
+const accountPatch = mutation({
+	args: {
+		accountId: v.id("Account"),
+		data: v.any()
+	},
+	returns: v.null(),
+	handler: async (ctx, { accountId, data }) => {
+		await ctx.db.patch("Account", accountId, data);
+		return null;
+	}
+});
+/**
+* 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 },
+* );
+* ```
+*/
+const accountDelete = mutation({
+	args: { accountId: v.id("Account") },
+	returns: v.null(),
+	handler: async (ctx, { accountId }) => {
+		await ctx.db.delete("Account", accountId);
+		return null;
+	}
+});
+
+//#endregion
+export { accountDelete, accountGet, accountGetById, accountInsert, accountListByUser, accountPatch };
+//# sourceMappingURL=accounts.js.map

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

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

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

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

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

@@ -0,0 +1,140 @@
+import { mutation, query } from "../../functions.js";
+import { vVerificationCodeDoc } from "../../model.js";
+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}`);
+* }
+* ```
+*/
+const verificationCodeGetByCode = query({
+	args: { code: 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)).unique();
+	}
+});
+/**
+* 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",
+*   },
+* );
+* ```
+*/
+const verificationCodeCreate = mutation({
+	args: {
+		accountId: v.id("Account"),
+		provider: v.string(),
+		code: v.string(),
+		expirationTime: v.number(),
+		verifier: v.optional(v.string()),
+		emailVerified: v.optional(v.string()),
+		phoneVerified: v.optional(v.string())
+	},
+	returns: v.id("VerificationCode"),
+	handler: async (ctx, args) => {
+		return await ctx.db.insert("VerificationCode", args);
+	}
+});
+/**
+* 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 },
+* );
+* ```
+*/
+const verificationCodeDelete = mutation({
+	args: { verificationCodeId: v.id("VerificationCode") },
+	returns: v.null(),
+	handler: async (ctx, { verificationCodeId }) => {
+		await ctx.db.delete("VerificationCode", verificationCodeId);
+		return null;
+	}
+});
+
+//#endregion
+export { verificationCodeCreate, verificationCodeDelete, verificationCodeGetByAccountId, verificationCodeGetByCode };
+//# sourceMappingURL=codes.js.map

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

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