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

package/dist/component/public/factors/devices.js

@@ -21,19 +21,6 @@ import { v } from "convex/values";
 * @param status - Initial status of the device authorization (e.g. `"pending"`).
 * @returns The `_id` of the newly created `DeviceCode` document.
 *
-* @example
-* ```ts
-* const deviceCodeId = await ctx.runMutation(
-*   components.auth.factors.devices.deviceInsert,
-*   {
-*     deviceCodeHash: "a1b2c3d4e5f6...",
-*     userCode: "ABCD-1234",
-*     expiresAt: Date.now() + 10 * 60 * 1000,
-*     interval: 5,
-*     status: "pending",
-*   },
-* );
-* ```
 */
 const deviceInsert = mutation({
 	args: {
@@ -49,62 +36,36 @@ const deviceInsert = mutation({
 	}
 });
 /**
-* Look up a device authorization record by its hashed device code.
+* Read a device authorization record by identity.
+*
+* Accepts exactly one selector:
+* - `id` — direct document lookup by `DeviceCode` `_id`.
+* - `deviceCodeHash` — lookup via the `device_code_hash` index. This is
+*   the primary lookup used by the token endpoint when a device client
+*   polls for authorization status.
+* - `userCode` — the first `"pending"` record matching the user-facing
+*   code, via the `user_code_status` compound index. Used when an
+*   authenticated user enters the code shown on the device to approve it.
+*
+* @param id - Optional `_id` of the `DeviceCode` document to retrieve.
+* @param deviceCodeHash - Optional SHA-256 hash of the device code.
+* @param userCode - Optional short, human-readable code the user typed
+*   in (e.g. `"ABCD-1234"`).
+* @returns The matching `DeviceCode` document, or `null` if none matches.
 *
-* Queries the `DeviceCode` table using the `device_code_hash` index.
-* This is the primary lookup used by the token endpoint when a device
-* client polls for authorization status.
-*
-* @param deviceCodeHash - SHA-256 hash of the device code to look up.
-* @returns The matching `DeviceCode` document, or `null` if no record
-*   exists for the given hash.
-*
-* @example
-* ```ts
-* const deviceCode = await ctx.runQuery(
-*   components.auth.factors.devices.deviceGetByCodeHash,
-*   { deviceCodeHash: "a1b2c3d4e5f6..." },
-* );
-* if (deviceCode && deviceCode.status === "authorized") {
-*   // Exchange for tokens
-* }
-* ```
 */
-const deviceGetByCodeHash = query({
-	args: { deviceCodeHash: v.string() },
-	returns: v.union(vDeviceCodeDoc, v.null()),
-	handler: async (ctx, { deviceCodeHash }) => {
-		return await ctx.db.query("DeviceCode").withIndex("device_code_hash", (q) => q.eq("deviceCodeHash", deviceCodeHash)).first();
-	}
-});
-/**
-* Look up a pending device authorization by its user-facing code.
-*
-* Queries the `DeviceCode` table using the `user_code_status` compound index,
-* filtering to only `"pending"` records. This is called when an authenticated
-* user enters the code shown on the device to approve the authorization.
-*
-* @param userCode - The short, human-readable code the user typed in
-*   (e.g. `"ABCD-1234"`).
-* @returns The matching pending `DeviceCode` document, or `null` if no
-*   pending authorization exists for the given user code.
-*
-* @example
-* ```ts
-* const pending = await ctx.runQuery(
-*   components.auth.factors.devices.deviceGetByUserCode,
-*   { userCode: "ABCD-1234" },
-* );
-* if (pending === null) {
-*   throw new Error("Invalid or expired user code");
-* }
-* ```
-*/
-const deviceGetByUserCode = query({
-	args: { userCode: v.string() },
+const deviceGet = query({
+	args: {
+		id: v.optional(v.id("DeviceCode")),
+		deviceCodeHash: v.optional(v.string()),
+		userCode: v.optional(v.string())
+	},
 	returns: v.union(vDeviceCodeDoc, v.null()),
-	handler: async (ctx, { userCode }) => {
-		return await ctx.db.query("DeviceCode").withIndex("user_code_status", (q) => q.eq("userCode", userCode).eq("status", "pending")).first();
+	handler: async (ctx, args) => {
+		if (args.deviceCodeHash !== void 0) return await ctx.db.query("DeviceCode").withIndex("device_code_hash", (q) => q.eq("deviceCodeHash", args.deviceCodeHash)).first();
+		if (args.userCode !== void 0) return await ctx.db.query("DeviceCode").withIndex("user_code_status", (q) => q.eq("userCode", args.userCode).eq("status", "pending")).first();
+		if (args.id === void 0) return null;
+		return await ctx.db.get("DeviceCode", args.id);
 	}
 });
 /**
@@ -121,17 +82,6 @@ const deviceGetByUserCode = query({
 *   approving user's current login.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.devices.deviceAuthorize,
-*   {
-*     deviceId: pending._id,
-*     userId: currentUser._id,
-*     sessionId: currentSession._id,
-*   },
-* );
-* ```
 */
 const deviceAuthorize = mutation({
 	args: {
@@ -150,36 +100,25 @@ const deviceAuthorize = mutation({
 	}
 });
 /**
-* Update the last-polled timestamp on a device authorization record.
+* Partially update a device authorization record.
 *
-* Called each time the device client polls the token endpoint. The
-* timestamp is used to enforce the minimum polling interval and to
-* detect slow-polling violations per RFC 8628.
+* Performs a partial patch on the `DeviceCode` document — e.g. bumping
+* `lastPolledAt` on each poll to enforce the minimum polling interval
+* and detect slow-polling violations per RFC 8628.
 *
 * @param deviceId - The `_id` of the `DeviceCode` document to update.
-* @param lastPolledAt - Unix timestamp (in milliseconds) of the most
-*   recent poll request from the device client.
+* @param data - An object containing the fields to patch.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.devices.deviceUpdateLastPolled,
-*   {
-*     deviceId: deviceCode._id,
-*     lastPolledAt: Date.now(),
-*   },
-* );
-* ```
 */
-const deviceUpdateLastPolled = mutation({
+const deviceUpdate = mutation({
 	args: {
 		deviceId: v.id("DeviceCode"),
-		lastPolledAt: v.number()
+		data: v.any()
 	},
 	returns: v.null(),
-	handler: async (ctx, { deviceId, lastPolledAt }) => {
-		await ctx.db.patch("DeviceCode", deviceId, { lastPolledAt });
+	handler: async (ctx, { deviceId, data }) => {
+		await ctx.db.patch("DeviceCode", deviceId, data);
 		return null;
 	}
 });
@@ -193,14 +132,6 @@ const deviceUpdateLastPolled = mutation({
 * @param deviceId - The `_id` of the `DeviceCode` document to delete.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* // Clean up after successful token exchange
-* await ctx.runMutation(
-*   components.auth.factors.devices.deviceDelete,
-*   { deviceId: deviceCode._id },
-* );
-* ```
 */
 const deviceDelete = mutation({
 	args: { deviceId: v.id("DeviceCode") },
@@ -212,5 +143,5 @@ const deviceDelete = mutation({
 });
 
 //#endregion
-export { deviceAuthorize, deviceDelete, deviceGetByCodeHash, deviceGetByUserCode, deviceInsert, deviceUpdateLastPolled };
+export { deviceAuthorize, deviceDelete, deviceGet, deviceInsert, deviceUpdate };
 //# sourceMappingURL=devices.js.map

package/dist/component/public/factors/passkeys.js

@@ -32,24 +32,6 @@ import { v } from "convex/values";
 *   was registered.
 * @returns The `_id` of the newly created `Passkey` document.
 *
-* @example
-* ```ts
-* const passkeyId = await ctx.runMutation(
-*   components.auth.factors.passkeys.passkeyInsert,
-*   {
-*     userId: user._id,
-*     credentialId: "dGVzdC1jcmVkZW50aWFs",
-*     publicKey: publicKeyBytes,
-*     algorithm: -7,
-*     counter: 0,
-*     transports: ["internal"],
-*     deviceType: "multiDevice",
-*     backedUp: true,
-*     name: "MacBook Pro Touch ID",
-*     createdAt: Date.now(),
-*   },
-* );
-* ```
 */
 const passkeyInsert = mutation({
 	args: {
@@ -70,63 +52,30 @@ const passkeyInsert = mutation({
 	}
 });
 /**
-* Look up a passkey by its credential ID.
+* Read a passkey by identity.
 *
-* Queries the `Passkey` table using the `credential_id` unique index.
-* This is the primary lookup during a WebAuthn authentication ceremony:
-* the authenticator provides a credential ID, and this function retrieves
-* the corresponding public key and counter for signature verification.
+* Accepts exactly one selector:
+* - `id` — direct document lookup by `Passkey` `_id`.
+* - `credentialId` — lookup via the `credential_id` unique index. This
+*   is the primary lookup during a WebAuthn authentication ceremony: the
+*   authenticator provides a credential ID, and this resolves the
+*   corresponding public key and counter for signature verification.
 *
-* @param credentialId - Base64url-encoded credential identifier to search for.
-* @returns The matching `Passkey` document, or `null` if no passkey exists
-*   with the given credential ID.
+* @param id - Optional `_id` of the `Passkey` document to retrieve.
+* @param credentialId - Optional base64url-encoded credential identifier.
+* @returns The matching `Passkey` document, or `null` if none matches.
 *
-* @example
-* ```ts
-* const passkey = await ctx.runQuery(
-*   components.auth.factors.passkeys.passkeyGetByCredentialId,
-*   { credentialId: "dGVzdC1jcmVkZW50aWFs" },
-* );
-* if (passkey === null) {
-*   throw new Error("Unknown credential");
-* }
-* ```
 */
-const passkeyGetByCredentialId = query({
-	args: { credentialId: v.string() },
-	returns: v.union(vPasskeyDoc, v.null()),
-	handler: async (ctx, { credentialId }) => {
-		return await ctx.db.query("Passkey").withIndex("credential_id", (q) => q.eq("credentialId", credentialId)).unique();
-	}
-});
-/**
-* Get a single passkey by its document ID.
-*
-* Performs a direct point lookup on the `Passkey` table. Returns `null`
-* when no passkey exists with the given ID (e.g. it was already deleted).
-* Useful when callers already hold a passkey ID and need to inspect the
-* document — for example to capture the owning `userId` before deletion.
-*
-* @param passkeyId - The `_id` of the `Passkey` document to retrieve.
-* @returns The `Passkey` document, or `null` if no passkey exists with the
-*   given ID.
-*
-* @example
-* ```ts
-* const passkey = await ctx.runQuery(
-*   components.auth.factors.passkeys.passkeyGetById,
-*   { passkeyId },
-* );
-* if (passkey === null) {
-*   throw new Error("Passkey not found");
-* }
-* ```
-*/
-const passkeyGetById = query({
-	args: { passkeyId: v.id("Passkey") },
+const passkeyGet = query({
+	args: {
+		id: v.optional(v.id("Passkey")),
+		credentialId: v.optional(v.string())
+	},
 	returns: v.union(vPasskeyDoc, v.null()),
-	handler: async (ctx, { passkeyId }) => {
-		return await ctx.db.get("Passkey", passkeyId);
+	handler: async (ctx, args) => {
+		if (args.credentialId !== void 0) return await ctx.db.query("Passkey").withIndex("credential_id", (q) => q.eq("credentialId", args.credentialId)).unique();
+		if (args.id === void 0) return null;
+		return await ctx.db.get("Passkey", args.id);
 	}
 });
 /**
@@ -141,19 +90,8 @@ const passkeyGetById = query({
 * @returns An array of `Passkey` documents. Returns an empty array if the
 *   user has no registered passkeys.
 *
-* @example
-* ```ts
-* const passkeys = await ctx.runQuery(
-*   components.auth.factors.passkeys.passkeyListByUserId,
-*   { userId: user._id },
-* );
-* // Display each passkey's name and creation date
-* for (const pk of passkeys) {
-*   console.log(pk.name, new Date(pk.createdAt));
-* }
-* ```
 */
-const passkeyListByUserId = query({
+const passkeyList = query({
 	args: { userId: v.id("User") },
 	returns: v.array(vPasskeyDoc),
 	handler: async (ctx, { userId }) => {
@@ -161,71 +99,20 @@ const passkeyListByUserId = query({
 	}
 });
 /**
-* Update a passkey's signature counter and last-used timestamp after
-* a successful authentication.
-*
-* After verifying a WebAuthn assertion, the relying party must persist
-* the new counter value reported by the authenticator. A counter that
-* does not increase may indicate a cloned credential.
-*
-* @param passkeyId - The `_id` of the `Passkey` document to update.
-* @param counter - The new signature counter value returned by the
-*   authenticator in the assertion response.
-* @param lastUsedAt - Unix timestamp (in milliseconds) recording when
-*   this passkey was most recently used to authenticate.
-* @returns `null` on success.
-*
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.passkeys.passkeyUpdateCounter,
-*   {
-*     passkeyId: passkey._id,
-*     counter: assertionResponse.counter,
-*     lastUsedAt: Date.now(),
-*   },
-* );
-* ```
-*/
-const passkeyUpdateCounter = mutation({
-	args: {
-		passkeyId: v.id("Passkey"),
-		counter: v.number(),
-		lastUsedAt: v.number()
-	},
-	returns: v.null(),
-	handler: async (ctx, { passkeyId, counter, lastUsedAt }) => {
-		await ctx.db.patch("Passkey", passkeyId, {
-			counter,
-			lastUsedAt
-		});
-		return null;
-	}
-});
-/**
-* Update a passkey's metadata fields.
+* Partially update a passkey document.
 *
-* Performs a partial patch on the `Passkey` document. Typically used to
-* rename a passkey (e.g. from `"Security Key"` to `"YubiKey 5C"`), but
-* can update any mutable fields via the `data` argument.
+* Performs a partial patch on the `Passkey` document. Used both to
+* rename a passkey (`{ name }`) and to persist the signature counter
+* and last-used timestamp after a successful WebAuthn assertion
+* (`{ counter, lastUsedAt }`) — a counter that does not increase may
+* indicate a cloned credential.
 *
 * @param passkeyId - The `_id` of the `Passkey` document to update.
-* @param data - An object containing the fields to patch. Commonly
-*   includes `{ name: "New Label" }`, but accepts any valid passkey fields.
+* @param data - An object containing the fields to patch.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.passkeys.passkeyUpdateMeta,
-*   {
-*     passkeyId: passkey._id,
-*     data: { name: "YubiKey 5C NFC" },
-*   },
-* );
-* ```
 */
-const passkeyUpdateMeta = mutation({
+const passkeyUpdate = mutation({
 	args: {
 		passkeyId: v.id("Passkey"),
 		data: v.any()
@@ -246,13 +133,6 @@ const passkeyUpdateMeta = mutation({
 * @param passkeyId - The `_id` of the `Passkey` document to delete.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.passkeys.passkeyDelete,
-*   { passkeyId: passkey._id },
-* );
-* ```
 */
 const passkeyDelete = mutation({
 	args: { passkeyId: v.id("Passkey") },
@@ -264,5 +144,5 @@ const passkeyDelete = mutation({
 });
 
 //#endregion
-export { passkeyDelete, passkeyGetByCredentialId, passkeyGetById, passkeyInsert, passkeyListByUserId, passkeyUpdateCounter, passkeyUpdateMeta };
+export { passkeyDelete, passkeyGet, passkeyInsert, passkeyList, passkeyUpdate };
 //# sourceMappingURL=passkeys.js.map

package/dist/component/public/factors/totp.js

@@ -24,21 +24,6 @@ import { v } from "convex/values";
 *   was created.
 * @returns The `_id` of the newly created `TotpFactor` document.
 *
-* @example
-* ```ts
-* const totpId = await ctx.runMutation(
-*   components.auth.factors.totp.totpInsert,
-*   {
-*     userId: user._id,
-*     secret: crypto.getRandomValues(new Uint8Array(20)),
-*     digits: 6,
-*     period: 30,
-*     verified: false,
-*     name: "Authenticator App",
-*     createdAt: Date.now(),
-*   },
-* );
-* ```
 */
 const totpInsert = mutation({
 	args: {
@@ -56,34 +41,31 @@ const totpInsert = mutation({
 	}
 });
 /**
-* Get a verified TOTP enrollment for a user.
+* Read a TOTP enrollment by identity.
 *
-* Queries the `TotpFactor` table using the `user_id_verified` compound
-* index to find the first enrollment that has been successfully verified.
-* This is the primary lookup during a TOTP authentication challenge --
-* only verified enrollments should be used to validate codes.
+* Accepts exactly one selector:
+* - `id` — direct document lookup by `TotpFactor` `_id`.
+* - `verifiedForUserId` — the first verified enrollment for the given
+*   user, via the `user_id_verified` compound index. This is the primary
+*   lookup during a TOTP authentication challenge, since only verified
+*   enrollments may validate codes.
 *
-* @param userId - The `_id` of the `User` whose verified TOTP enrollment
-*   to retrieve.
-* @returns The first verified `TotpFactor` document for the user, or
-*   `null` if the user has no verified TOTP enrollment.
+* @param id - Optional `_id` of the `TotpFactor` document to retrieve.
+* @param verifiedForUserId - Optional `_id` of the `User` whose first
+*   verified enrollment to retrieve.
+* @returns The matching `TotpFactor` document, or `null` if none matches.
 *
-* @example
-* ```ts
-* const totp = await ctx.runQuery(
-*   components.auth.factors.totp.totpGetVerifiedByUserId,
-*   { userId: user._id },
-* );
-* if (totp === null) {
-*   // User does not have TOTP 2FA enabled
-* }
-* ```
 */
-const totpGetVerifiedByUserId = query({
-	args: { userId: v.id("User") },
+const totpGet = query({
+	args: {
+		id: v.optional(v.id("TotpFactor")),
+		verifiedForUserId: v.optional(v.id("User"))
+	},
 	returns: v.union(vTotpFactorDoc, v.null()),
-	handler: async (ctx, { userId }) => {
-		return await ctx.db.query("TotpFactor").withIndex("user_id_verified", (q) => q.eq("userId", userId).eq("verified", true)).first();
+	handler: async (ctx, args) => {
+		if (args.verifiedForUserId !== void 0) return await ctx.db.query("TotpFactor").withIndex("user_id_verified", (q) => q.eq("userId", args.verifiedForUserId).eq("verified", true)).first();
+		if (args.id === void 0) return null;
+		return await ctx.db.get("TotpFactor", args.id);
 	}
 });
 /**
@@ -99,17 +81,8 @@ const totpGetVerifiedByUserId = query({
 * @returns An array of `TotpFactor` documents. Returns an empty array if
 *   the user has no TOTP enrollments.
 *
-* @example
-* ```ts
-* const factors = await ctx.runQuery(
-*   components.auth.factors.totp.totpListByUserId,
-*   { userId: user._id },
-* );
-* const verified = factors.filter((f) => f.verified);
-* const pending = factors.filter((f) => !f.verified);
-* ```
 */
-const totpListByUserId = query({
+const totpList = query({
 	args: { userId: v.id("User") },
 	returns: v.array(vTotpFactorDoc),
 	handler: async (ctx, { userId }) => {
@@ -117,111 +90,26 @@ const totpListByUserId = query({
 	}
 });
 /**
-* Get a single TOTP enrollment by its document ID.
-*
-* Performs a direct document lookup on the `TotpFactor` table. This is
-* used when you already have the enrollment's `_id` (e.g. from a
-* previous list query) and need to fetch its full details, including
-* the secret and verification status.
-*
-* @param totpId - The `_id` of the `TotpFactor` document to retrieve.
-* @returns The `TotpFactor` document, or `null` if no enrollment exists
-*   with the given ID.
-*
-* @example
-* ```ts
-* const totp = await ctx.runQuery(
-*   components.auth.factors.totp.totpGetById,
-*   { totpId: enrollmentId },
-* );
-* if (totp !== null && !totp.verified) {
-*   // Enrollment is still pending confirmation
-* }
-* ```
-*/
-const totpGetById = query({
-	args: { totpId: v.id("TotpFactor") },
-	returns: v.union(vTotpFactorDoc, v.null()),
-	handler: async (ctx, { totpId }) => {
-		return await ctx.db.get("TotpFactor", totpId);
-	}
-});
-/**
-* Mark a TOTP enrollment as verified, completing the setup process.
-*
-* Called after the user successfully submits a valid TOTP code during
-* enrollment. This transitions the factor from a pending state to an
-* active, verified state, enabling it for future authentication
-* challenges.
-*
-* @param totpId - The `_id` of the `TotpFactor` document to mark as
-*   verified.
-* @param lastUsedAt - Unix timestamp (in milliseconds) recording when
-*   the verification code was successfully validated.
-* @returns `null` on success.
-*
-* @example
-* ```ts
-* // After validating the user's TOTP code during setup
-* await ctx.runMutation(
-*   components.auth.factors.totp.totpMarkVerified,
-*   {
-*     totpId: enrollment._id,
-*     lastUsedAt: Date.now(),
-*   },
-* );
-* ```
-*/
-const totpMarkVerified = mutation({
-	args: {
-		totpId: v.id("TotpFactor"),
-		lastUsedAt: v.number()
-	},
-	returns: v.null(),
-	handler: async (ctx, { totpId, lastUsedAt }) => {
-		await ctx.db.patch("TotpFactor", totpId, {
-			verified: true,
-			lastUsedAt
-		});
-		const factor = await ctx.db.get("TotpFactor", totpId);
-		if (factor !== null) {
-			const user = await ctx.db.get("User", factor.userId);
-			if (user !== null && user.hasTotp !== true) await ctx.db.patch("User", factor.userId, { hasTotp: true });
-		}
-		return null;
-	}
-});
-/**
-* Update a TOTP enrollment's last-used timestamp.
+* Partially update a TOTP enrollment.
 *
-* Called after each successful TOTP code validation during sign-in.
-* Tracking the last-used time helps detect stale enrollments and can
-* be surfaced in security settings for user awareness.
+* Performs a partial patch on the `TotpFactor` document. Used to confirm
+* an enrollment (`{ verified: true, lastUsedAt }`) and to bump
+* `lastUsedAt` after each successful validation (stale-enrollment
+* tracking).
 *
 * @param totpId - The `_id` of the `TotpFactor` document to update.
-* @param lastUsedAt - Unix timestamp (in milliseconds) recording when
-*   the TOTP code was most recently validated.
+* @param data - An object containing the fields to patch.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* await ctx.runMutation(
-*   components.auth.factors.totp.totpUpdateLastUsed,
-*   {
-*     totpId: totp._id,
-*     lastUsedAt: Date.now(),
-*   },
-* );
-* ```
 */
-const totpUpdateLastUsed = mutation({
+const totpUpdate = mutation({
 	args: {
 		totpId: v.id("TotpFactor"),
-		lastUsedAt: v.number()
+		data: v.any()
 	},
 	returns: v.null(),
-	handler: async (ctx, { totpId, lastUsedAt }) => {
-		await ctx.db.patch("TotpFactor", totpId, { lastUsedAt });
+	handler: async (ctx, { totpId, data }) => {
+		await ctx.db.patch("TotpFactor", totpId, data);
 		return null;
 	}
 });
@@ -236,31 +124,16 @@ const totpUpdateLastUsed = mutation({
 * @param totpId - The `_id` of the `TotpFactor` document to delete.
 * @returns `null` on success.
 *
-* @example
-* ```ts
-* // User disables TOTP 2FA
-* await ctx.runMutation(
-*   components.auth.factors.totp.totpDelete,
-*   { totpId: totp._id },
-* );
-* ```
 */
 const totpDelete = mutation({
 	args: { totpId: v.id("TotpFactor") },
 	returns: v.null(),
 	handler: async (ctx, { totpId }) => {
-		const factor = await ctx.db.get("TotpFactor", totpId);
 		await ctx.db.delete("TotpFactor", totpId);
-		if (factor !== null && factor.verified) {
-			if (await ctx.db.query("TotpFactor").withIndex("user_id_verified", (q) => q.eq("userId", factor.userId).eq("verified", true)).first() === null) {
-				const user = await ctx.db.get("User", factor.userId);
-				if (user !== null && user.hasTotp === true) await ctx.db.patch("User", factor.userId, { hasTotp: false });
-			}
-		}
 		return null;
 	}
 });
 
 //#endregion
-export { totpDelete, totpGetById, totpGetVerifiedByUserId, totpInsert, totpListByUserId, totpMarkVerified, totpUpdateLastUsed };
+export { totpDelete, totpGet, totpInsert, totpList, totpUpdate };
 //# sourceMappingURL=totp.js.map