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

package/dist/server/implementation/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/server/implementation/index.ts"],"mappings":"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"}

package/dist/server/implementation/index.js

@@ -1,610 +0,0 @@
-import { isAuthError, throwAuthError } from "../errors.js";
-import { requireEnv } from "../utils.js";
-import { redirectToParamCookie, useRedirectToParam } from "../cookies.js";
-import { configDefaults, listAvailableProviders, materializeProvider } from "../providers.js";
-import { LOG_LEVELS, TOKEN_SUB_CLAIM_DIVIDER, logError, logWithLevel } from "./utils.js";
-import { callSignOut } from "./mutations/signout.js";
-import { callVerifierSignature } from "./mutations/signature.js";
-import { callUserOAuth } from "./mutations/oauth.js";
-import { callCreateAccountFromCredentials } from "./mutations/register.js";
-import { callRetreiveAccountWithCredentials } from "./mutations/retrieve.js";
-import { callModifyAccount } from "./mutations/account.js";
-import { callInvalidateSessions } from "./mutations/invalidate.js";
-import { storeArgs, storeImpl } from "./mutations/index.js";
-import { redirectAbsoluteUrl, setURLSearchParam } from "./redirects.js";
-import { signInImpl } from "./signin.js";
-import { buildScopeChecker, checkKeyRateLimit, generateApiKey, hashApiKey, validateScopes } from "./keys.js";
-import { createOAuthAuthorizationURL, handleOAuthCallback } from "../oauth.js";
-import { actionGeneric, httpActionGeneric, internalMutationGeneric } from "convex/server";
-import { ConvexError, v } from "convex/values";
-import { parse, serialize } from "cookie";
-
-//#region src/server/implementation/index.ts
-/**
-* Configure the Convex Auth library. Returns an object with
-* functions and `auth` helper. You must export the functions
-* from `convex/auth.ts` to make them callable:
-*
-* ```ts filename="convex/auth.ts"
-* import { Auth } from "@robelest/convex-auth/component";
-* import { components } from "./_generated/api";
-*
-* export const { auth, signIn, signOut, store } = Auth({
-*   component: components.auth,
-*   providers: [],
-* });
-* ```
-*
-* @returns An object with fields you should reexport from your
-*          `convex/auth.ts` file.
-*/
-function Auth(config_) {
-	const config = configDefaults(config_);
-	const hasOAuth = config.providers.some((provider) => provider.type === "oauth");
-	const getProvider = (id, allowExtraProviders = false) => {
-		return config.providers.find((provider) => provider.id === id) ?? (allowExtraProviders ? config.extraProviders.find((provider) => provider.id === id) : void 0);
-	};
-	const getProviderOrThrow = (id, allowExtraProviders = false) => {
-		const provider = getProvider(id, allowExtraProviders);
-		if (provider === void 0) {
-			const detail = `Provider \`${id}\` is not configured, available providers are ${listAvailableProviders(config, allowExtraProviders)}.`;
-			logWithLevel(LOG_LEVELS.ERROR, detail);
-			throwAuthError("PROVIDER_NOT_CONFIGURED", detail, { provider: id });
-		}
-		return provider;
-	};
-	const auth = {
-		user: {
-			current: async (ctx) => {
-				const identity = await ctx.auth.getUserIdentity();
-				if (identity === null) return null;
-				const [userId] = identity.subject.split(TOKEN_SUB_CLAIM_DIVIDER);
-				return userId;
-			},
-			require: async (ctx) => {
-				const identity = await ctx.auth.getUserIdentity();
-				if (identity === null) throwAuthError("NOT_SIGNED_IN");
-				const [userId] = identity.subject.split(TOKEN_SUB_CLAIM_DIVIDER);
-				return userId;
-			},
-			get: async (ctx, userId) => {
-				return await ctx.runQuery(config.component.public.userGetById, { userId });
-			},
-			list: async (ctx, opts = {}) => {
-				return await ctx.runQuery(config.component.public.userList, opts);
-			},
-			viewer: async (ctx) => {
-				const userId = await auth.user.current(ctx);
-				if (userId === null) return null;
-				return await ctx.runQuery(config.component.public.userGetById, { userId });
-			},
-			patch: async (ctx, userId, data) => {
-				await ctx.runMutation(config.component.public.userPatch, {
-					userId,
-					data
-				});
-			},
-			group: {
-				list: async (ctx, opts) => {
-					return await ctx.runQuery(config.component.public.memberList, {
-						where: { userId: opts.userId },
-						limit: opts.limit,
-						cursor: opts.cursor,
-						order: opts.order
-					});
-				},
-				get: async (ctx, opts) => {
-					return await ctx.runQuery(config.component.public.memberGetByGroupAndUser, opts);
-				}
-			}
-		},
-		session: {
-			current: async (ctx) => {
-				const identity = await ctx.auth.getUserIdentity();
-				if (identity === null) return null;
-				const [, sessionId] = identity.subject.split(TOKEN_SUB_CLAIM_DIVIDER);
-				return sessionId;
-			},
-			invalidate: async (ctx, args) => {
-				return await callInvalidateSessions(ctx, args);
-			}
-		},
-		account: {
-			create: async (ctx, args) => {
-				return await callCreateAccountFromCredentials(ctx, args);
-			},
-			get: async (ctx, args) => {
-				const result = await callRetreiveAccountWithCredentials(ctx, args);
-				if (typeof result === "string") throwAuthError("ACCOUNT_NOT_FOUND", result);
-				return result;
-			},
-			update: async (ctx, args) => {
-				return await callModifyAccount(ctx, args);
-			}
-		},
-		provider: { signIn: async (ctx, provider, args) => {
-			const result = await signInImpl(enrichCtx(ctx), materializeProvider(provider), args, {
-				generateTokens: false,
-				allowExtraProviders: true
-			});
-			return result.kind === "signedIn" ? result.signedIn !== null ? {
-				userId: result.signedIn.userId,
-				sessionId: result.signedIn.sessionId
-			} : null : null;
-		} },
-		group: {
-			create: async (ctx, data) => {
-				return await ctx.runMutation(config.component.public.groupCreate, data);
-			},
-			get: async (ctx, groupId) => {
-				return await ctx.runQuery(config.component.public.groupGet, { groupId });
-			},
-			list: async (ctx, opts) => {
-				return await ctx.runQuery(config.component.public.groupList, {
-					where: opts?.where,
-					limit: opts?.limit,
-					cursor: opts?.cursor,
-					orderBy: opts?.orderBy,
-					order: opts?.order
-				});
-			},
-			update: async (ctx, groupId, data) => {
-				await ctx.runMutation(config.component.public.groupUpdate, {
-					groupId,
-					data
-				});
-			},
-			delete: async (ctx, groupId) => {
-				await ctx.runMutation(config.component.public.groupDelete, { groupId });
-			},
-			member: {
-				add: async (ctx, data) => {
-					return await ctx.runMutation(config.component.public.memberAdd, data);
-				},
-				get: async (ctx, memberId) => {
-					return await ctx.runQuery(config.component.public.memberGet, { memberId });
-				},
-				list: async (ctx, opts) => {
-					return await ctx.runQuery(config.component.public.memberList, {
-						where: opts?.where,
-						limit: opts?.limit,
-						cursor: opts?.cursor,
-						orderBy: opts?.orderBy,
-						order: opts?.order
-					});
-				},
-				remove: async (ctx, memberId) => {
-					await ctx.runMutation(config.component.public.memberRemove, { memberId });
-				},
-				update: async (ctx, memberId, data) => {
-					await ctx.runMutation(config.component.public.memberUpdate, {
-						memberId,
-						data
-					});
-				}
-			}
-		},
-		invite: {
-			create: async (ctx, data) => {
-				return await ctx.runMutation(config.component.public.inviteCreate, data);
-			},
-			get: async (ctx, inviteId) => {
-				return await ctx.runQuery(config.component.public.inviteGet, { inviteId });
-			},
-			list: async (ctx, opts) => {
-				return await ctx.runQuery(config.component.public.inviteList, {
-					where: opts?.where,
-					limit: opts?.limit,
-					cursor: opts?.cursor,
-					orderBy: opts?.orderBy,
-					order: opts?.order
-				});
-			},
-			accept: async (ctx, inviteId, acceptedByUserId) => {
-				await ctx.runMutation(config.component.public.inviteAccept, {
-					inviteId,
-					...acceptedByUserId ? { acceptedByUserId } : {}
-				});
-			},
-			revoke: async (ctx, inviteId) => {
-				await ctx.runMutation(config.component.public.inviteRevoke, { inviteId });
-			}
-		},
-		passkey: {
-			list: async (ctx, opts) => {
-				return await ctx.runQuery(config.component.public.passkeyListByUserId, opts);
-			},
-			rename: async (ctx, passkeyId, name) => {
-				await ctx.runMutation(config.component.public.passkeyUpdateMeta, {
-					passkeyId,
-					data: { name }
-				});
-			},
-			remove: async (ctx, passkeyId) => {
-				await ctx.runMutation(config.component.public.passkeyDelete, { passkeyId });
-			}
-		},
-		totp: {
-			list: async (ctx, opts) => {
-				return await ctx.runQuery(config.component.public.totpListByUserId, opts);
-			},
-			remove: async (ctx, totpId) => {
-				await ctx.runMutation(config.component.public.totpDelete, { totpId });
-			}
-		},
-		key: {
-			create: async (ctx, opts) => {
-				const prefix = config.apiKeys?.prefix ?? "sk_live_";
-				validateScopes(opts.scopes, config.apiKeys?.scopes);
-				const { raw, hashedKey, displayPrefix } = await generateApiKey(prefix);
-				return {
-					keyId: await ctx.runMutation(config.component.public.keyInsert, {
-						userId: opts.userId,
-						prefix: displayPrefix,
-						hashedKey,
-						name: opts.name,
-						scopes: opts.scopes,
-						rateLimit: opts.rateLimit ?? config.apiKeys?.defaultRateLimit,
-						expiresAt: opts.expiresAt
-					}),
-					raw
-				};
-			},
-			verify: async (ctx, rawKey) => {
-				const hashedKey = await hashApiKey(rawKey);
-				const key = await ctx.runQuery(config.component.public.keyGetByHashedKey, { hashedKey });
-				if (!key) throwAuthError("INVALID_API_KEY");
-				if (key.revoked) throwAuthError("API_KEY_REVOKED");
-				if (key.expiresAt && key.expiresAt < Date.now()) throwAuthError("API_KEY_EXPIRED");
-				const patchData = { lastUsedAt: Date.now() };
-				if (key.rateLimit) {
-					const { limited, newState } = checkKeyRateLimit(key.rateLimit, key.rateLimitState ?? void 0);
-					if (limited) throwAuthError("API_KEY_RATE_LIMITED");
-					patchData.rateLimitState = newState;
-				}
-				await ctx.runMutation(config.component.public.keyPatch, {
-					keyId: key._id,
-					data: patchData
-				});
-				return {
-					userId: key.userId,
-					keyId: key._id,
-					scopes: buildScopeChecker(key.scopes)
-				};
-			},
-			list: async (ctx, opts) => {
-				return await ctx.runQuery(config.component.public.keyList, {
-					where: opts?.where,
-					limit: opts?.limit,
-					cursor: opts?.cursor,
-					orderBy: opts?.orderBy,
-					order: opts?.order
-				});
-			},
-			get: async (ctx, keyId) => {
-				return await ctx.runQuery(config.component.public.keyGetById, { keyId });
-			},
-			update: async (ctx, keyId, data) => {
-				if (data.scopes) validateScopes(data.scopes, config.apiKeys?.scopes);
-				await ctx.runMutation(config.component.public.keyPatch, {
-					keyId,
-					data
-				});
-			},
-			revoke: async (ctx, keyId) => {
-				await ctx.runMutation(config.component.public.keyPatch, {
-					keyId,
-					data: { revoked: true }
-				});
-			},
-			remove: async (ctx, keyId) => {
-				await ctx.runMutation(config.component.public.keyDelete, { keyId });
-			}
-		},
-		http: {
-			add: (http) => {
-				http.route({
-					path: "/.well-known/openid-configuration",
-					method: "GET",
-					handler: httpActionGeneric(async () => {
-						return new Response(JSON.stringify({
-							issuer: requireEnv("CONVEX_SITE_URL"),
-							jwks_uri: requireEnv("CONVEX_SITE_URL") + "/.well-known/jwks.json",
-							authorization_endpoint: requireEnv("CONVEX_SITE_URL") + "/oauth/authorize"
-						}), {
-							status: 200,
-							headers: {
-								"Content-Type": "application/json",
-								"Cache-Control": "public, max-age=15, stale-while-revalidate=15, stale-if-error=86400"
-							}
-						});
-					})
-				});
-				http.route({
-					path: "/.well-known/jwks.json",
-					method: "GET",
-					handler: httpActionGeneric(async () => {
-						return new Response(requireEnv("JWKS"), {
-							status: 200,
-							headers: {
-								"Content-Type": "application/json",
-								"Cache-Control": "public, max-age=15, stale-while-revalidate=15, stale-if-error=86400"
-							}
-						});
-					})
-				});
-				if (hasOAuth) {
-					http.route({
-						pathPrefix: "/api/auth/signin/",
-						method: "GET",
-						handler: httpActionGeneric(convertErrorsToResponse(400, async (ctx, request) => {
-							const url = new URL(request.url);
-							const providerId = url.pathname.split("/").at(-1);
-							if (providerId === null) throwAuthError("OAUTH_MISSING_PROVIDER");
-							const verifier = url.searchParams.get("code");
-							if (verifier === null) throwAuthError("OAUTH_MISSING_VERIFIER");
-							const oauthConfig = getProviderOrThrow(providerId);
-							const { redirect, cookies, signature } = await createOAuthAuthorizationURL(providerId, oauthConfig.provider, oauthConfig);
-							await callVerifierSignature(ctx, {
-								verifier,
-								signature
-							});
-							const redirectTo = url.searchParams.get("redirectTo");
-							if (redirectTo !== null) cookies.push(redirectToParamCookie(providerId, redirectTo));
-							const headers = new Headers({ Location: redirect });
-							for (const { name, value, options } of cookies) headers.append("Set-Cookie", serialize(name, value, options));
-							return new Response(null, {
-								status: 302,
-								headers
-							});
-						}))
-					});
-					const callbackAction = httpActionGeneric(async (genericCtx, request) => {
-						const ctx = genericCtx;
-						const url = new URL(request.url);
-						const providerId = url.pathname.split("/").at(-1);
-						logWithLevel(LOG_LEVELS.DEBUG, "Handling OAuth callback for provider:", providerId);
-						const provider = getProviderOrThrow(providerId);
-						const cookies = getCookies(request);
-						const destinationUrl = await redirectAbsoluteUrl(config, { redirectTo: useRedirectToParam(provider.id, cookies)?.redirectTo });
-						const params = url.searchParams;
-						if (request.headers.get("Content-Type") === "application/x-www-form-urlencoded") {
-							const formData = await request.formData();
-							for (const [key, value] of formData.entries()) if (typeof value === "string") params.append(key, value);
-						}
-						try {
-							const oauthConfig = provider;
-							const result = await handleOAuthCallback(providerId, oauthConfig.provider, oauthConfig, Object.fromEntries(params.entries()), cookies);
-							const { id: profileId, ...profileData } = result.profile;
-							const { signature } = result;
-							const verificationCode = await callUserOAuth(ctx, {
-								provider: providerId,
-								providerAccountId: profileId,
-								profile: profileData,
-								signature
-							});
-							return new Response(null, {
-								status: 302,
-								headers: {
-									Location: setURLSearchParam(destinationUrl, "code", verificationCode),
-									"Cache-Control": "must-revalidate"
-								}
-							});
-						} catch (error) {
-							logError(error);
-							return Response.redirect(destinationUrl);
-						}
-					});
-					http.route({
-						pathPrefix: "/api/auth/callback/",
-						method: "GET",
-						handler: callbackAction
-					});
-					http.route({
-						pathPrefix: "/api/auth/callback/",
-						method: "POST",
-						handler: callbackAction
-					});
-				}
-			},
-			action: (handler, options) => {
-				const corsConfig = options?.cors ?? {};
-				const corsHeaders = {
-					"Access-Control-Allow-Origin": corsConfig.origin ?? "*",
-					"Access-Control-Allow-Methods": corsConfig.methods ?? "GET,POST,PUT,PATCH,DELETE,OPTIONS",
-					"Access-Control-Allow-Headers": corsConfig.headers ?? "Content-Type,Authorization"
-				};
-				const jsonError = (status, code, message) => new Response(JSON.stringify({
-					error: message,
-					code
-				}), {
-					status,
-					headers: {
-						...corsHeaders,
-						"Content-Type": "application/json"
-					}
-				});
-				return httpActionGeneric(async (genericCtx, request) => {
-					const ctx = genericCtx;
-					try {
-						const authHeader = request.headers.get("Authorization");
-						if (!authHeader?.startsWith("Bearer ")) return jsonError(401, "MISSING_BEARER_TOKEN", "Missing or malformed Authorization: Bearer header.");
-						const rawKey = authHeader.slice(7);
-						let keyResult;
-						try {
-							keyResult = await auth.key.verify(ctx, rawKey);
-						} catch (error) {
-							if (isAuthError(error)) {
-								const { code, message } = error.data;
-								return jsonError(403, code, message);
-							}
-							throw error;
-						}
-						if (options?.scope) {
-							if (!keyResult.scopes.can(options.scope.resource, options.scope.action)) return jsonError(403, "SCOPE_CHECK_FAILED", "This API key does not have the required permissions.");
-						}
-						const result = await handler(Object.assign(ctx, { key: {
-							userId: keyResult.userId,
-							keyId: keyResult.keyId,
-							scopes: keyResult.scopes
-						} }), request);
-						if (result instanceof Response) {
-							const headers = new Headers(result.headers);
-							for (const [k, val] of Object.entries(corsHeaders)) if (!headers.has(k)) headers.set(k, val);
-							return new Response(result.body, {
-								status: result.status,
-								statusText: result.statusText,
-								headers
-							});
-						}
-						return new Response(JSON.stringify(result), {
-							status: 200,
-							headers: {
-								...corsHeaders,
-								"Content-Type": "application/json"
-							}
-						});
-					} catch (error) {
-						logError(error);
-						return jsonError(500, "INTERNAL_ERROR", "An unexpected error occurred.");
-					}
-				});
-			},
-			route: (http, routeConfig) => {
-				const corsConfig = routeConfig.cors ?? {};
-				const corsHeaders = {
-					"Access-Control-Allow-Origin": corsConfig.origin ?? "*",
-					"Access-Control-Allow-Methods": corsConfig.methods ?? "GET,POST,PUT,PATCH,DELETE,OPTIONS",
-					"Access-Control-Allow-Headers": corsConfig.headers ?? "Content-Type,Authorization"
-				};
-				http.route({
-					path: routeConfig.path,
-					method: "OPTIONS",
-					handler: httpActionGeneric(async () => {
-						return new Response(null, {
-							status: 204,
-							headers: corsHeaders
-						});
-					})
-				});
-				http.route({
-					path: routeConfig.path,
-					method: routeConfig.method,
-					handler: auth.http.action(routeConfig.handler, {
-						scope: routeConfig.scope,
-						cors: routeConfig.cors
-					})
-				});
-			}
-		}
-	};
-	const enrichCtx = (ctx) => ({
-		...ctx,
-		auth: {
-			...ctx.auth,
-			config,
-			account: auth.account,
-			session: auth.session,
-			provider: auth.provider
-		}
-	});
-	return {
-		auth,
-		signIn: actionGeneric({
-			args: {
-				provider: v.optional(v.string()),
-				params: v.optional(v.any()),
-				verifier: v.optional(v.string()),
-				refreshToken: v.optional(v.string()),
-				calledBy: v.optional(v.string())
-			},
-			handler: async (ctx, args) => {
-				if (args.calledBy !== void 0) logWithLevel("INFO", `\`auth:signIn\` called by ${args.calledBy}`);
-				const provider = args.provider !== void 0 ? getProviderOrThrow(args.provider) : null;
-				const result = await signInImpl(enrichCtx(ctx), provider, args, {
-					generateTokens: true,
-					allowExtraProviders: false
-				});
-				switch (result.kind) {
-					case "redirect": return {
-						redirect: result.redirect,
-						verifier: result.verifier
-					};
-					case "signedIn":
-					case "refreshTokens": return { tokens: result.signedIn?.tokens ?? null };
-					case "started": return { started: true };
-					case "passkeyOptions": return {
-						options: result.options,
-						verifier: result.verifier
-					};
-					case "totpRequired": return {
-						totpRequired: true,
-						verifier: result.verifier
-					};
-					case "totpSetup": return {
-						totpSetup: {
-							uri: result.uri,
-							secret: result.secret,
-							totpId: result.totpId
-						},
-						verifier: result.verifier
-					};
-					case "deviceCode": return { deviceCode: {
-						deviceCode: result.deviceCode,
-						userCode: result.userCode,
-						verificationUri: result.verificationUri,
-						verificationUriComplete: result.verificationUriComplete,
-						expiresIn: result.expiresIn,
-						interval: result.interval
-					} };
-					default: throwAuthError("INTERNAL_ERROR", `Unexpected result from signIn, ${String(result)}`);
-				}
-			}
-		}),
-		signOut: actionGeneric({
-			args: {},
-			handler: async (ctx) => {
-				await callSignOut(ctx);
-			}
-		}),
-		store: internalMutationGeneric({
-			args: storeArgs,
-			handler: async (ctx, args) => {
-				return storeImpl(ctx, args, getProviderOrThrow, config);
-			}
-		})
-	};
-}
-function convertErrorsToResponse(errorStatusCode, action) {
-	return async (ctx, request) => {
-		try {
-			return await action(ctx, request);
-		} catch (error) {
-			if (isAuthError(error)) return new Response(JSON.stringify({
-				code: error.data.code,
-				message: error.data.message
-			}), {
-				status: errorStatusCode,
-				headers: { "Content-Type": "application/json" }
-			});
-			else if (error instanceof ConvexError) return new Response(null, {
-				status: errorStatusCode,
-				statusText: typeof error.data === "string" ? error.data : "Error"
-			});
-			else {
-				logError(error);
-				return new Response(null, {
-					status: 500,
-					statusText: "Internal Server Error"
-				});
-			}
-		}
-	};
-}
-function getCookies(request) {
-	return parse(request.headers.get("Cookie") ?? "");
-}
-
-//#endregion
-export { Auth };
-//# sourceMappingURL=index.js.map