faire-auth 1.0.0

package/dist/defu-B0Svx_x4.cjs

@@ -0,0 +1,34 @@
+
+//#region src/utils/defu.ts
+const isPlainObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+};
+const _defu = (baseObject, defaults, namespace = ".", merger) => {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger?.(object, key, value, namespace) != null) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+};
+const createDefu = (merger) => (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+const defu = createDefu();
+
+//#endregion
+Object.defineProperty(exports, 'defu', {
+  enumerable: true,
+  get: function () {
+    return defu;
+  }
+});

package/dist/defu-SZkpHhbR.mjs

@@ -0,0 +1,28 @@
+//#region src/utils/defu.ts
+const isPlainObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+};
+const _defu = (baseObject, defaults, namespace = ".", merger) => {
+	if (!isPlainObject(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = Object.assign({}, defaults);
+	for (const key in baseObject) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger?.(object, key, value, namespace) != null) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject(value) && isPlainObject(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+};
+const createDefu = (merger) => (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+const defu = createDefu();
+
+//#endregion
+export { defu as t };

package/dist/email-verification-C-AsfJsb.cjs

@@ -0,0 +1,247 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_crypto = require('./crypto-CcTxYH82.cjs');
+const require_cookies = require('./cookies-B5xeA6i8.cjs');
+const require_middleware = require('./middleware-CWvRH4EW.cjs');
+const require_session = require('./session-De9POJTW.cjs');
+const require_origin_check = require('./origin-check-id9lTnqZ.cjs');
+let __faire_auth_core_factory = require("@faire-auth/core/factory");
+let __faire_auth_core_static = require("@faire-auth/core/static");
+let __faire_auth_core_utils = require("@faire-auth/core/utils");
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
+let jose = require("jose");
+let jose_errors = require("jose/errors");
+
+//#region src/api/schema/email-verification.ts
+const sendVerificationEmailSchema = zod.object({
+	email: __faire_auth_core_factory.emailSchema.openapi({ description: "The email to send the verification email to" }),
+	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to use for email verification callback" })
+});
+const verifyEmailQuerySchema = zod.object({
+	token: zod.string().openapi({ description: "The token to verify the email" }),
+	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to after email verification" })
+});
+const verifyEmailTokenSchema = zod.object({
+	email: __faire_auth_core_factory.emailSchema,
+	updateTo: zod.string().optional()
+});
+
+//#endregion
+//#region src/api/middleware/token-check.ts
+const onError = async (ctx, error) => {
+	let code;
+	if (error === "missing_token") code = 400;
+	else code = 401;
+	const url = ctx.req.query("callbackURL");
+	if (url) {
+		if (url.includes("?")) return ctx.redirect(`${url}&error=${error}`, 302);
+		return ctx.redirect(`${url}?error=${error}`, 302);
+	}
+	return ctx.render({
+		success: __faire_auth_core_static.False,
+		code: error.toUpperCase(),
+		message: (0, __faire_auth_core_utils.capitalizeFirstLetter)(error.replaceAll("_", " "))
+	}, code);
+};
+const verifyToken = async (token, context) => {
+	let jwt;
+	try {
+		jwt = await (0, jose.jwtVerify)(token, new TextEncoder().encode(context.secret), { algorithms: ["HS256"] });
+	} catch (e) {
+		if (e instanceof jose_errors.JWTExpired) return "token_expired";
+		return "invalid_token";
+	}
+	return jwt;
+};
+/**
+* Validates token against context secret.
+* @template V - The context variables type.
+* @param getValue - Function to get the token from the context.
+* @returns The middleware function.
+*/
+const tokenCheck = (getValue, schema) => require_middleware.createMiddleware()(async (ctx, next) => {
+	const token = await getValue(ctx);
+	if (!token) return onError(ctx, "missing_token");
+	const res$1 = await verifyToken(token, ctx.get("context"));
+	if (typeof res$1 === "string") return onError(ctx, res$1);
+	const dat = await schema.safeParseAsync(res$1.payload);
+	if (dat.success === false) return onError(ctx, "invalid_token");
+	ctx.set("token", dat.data);
+	return await next();
+});
+
+//#endregion
+//#region src/api/routes/email-verification.ts
+const createEmailVerificationToken = async (secret, email, updateTo, expiresIn = 3600) => {
+	return await (0, require_crypto.crypto_exports.signJWT)({
+		email: email.toLowerCase(),
+		updateTo
+	}, secret, expiresIn);
+};
+/**
+* A function to send a verification email to the user
+*/
+const sendVerificationEmailFn = async (ctx, user, callbackURL = encodeURIComponent("/"), options) => {
+	const context = ctx.get("context");
+	if (!options?.emailVerification?.sendVerificationEmail) {
+		context.logger.error("Verification email isn't enabled.");
+		return ctx.render({
+			success: __faire_auth_core_static.False,
+			message: "Verification email isn't enabled"
+		}, 400);
+	}
+	const token = await createEmailVerificationToken(context.secret, user.email, void 0, options.emailVerification.expiresIn);
+	const url = `${context.baseURL}/verify-email?token=${token}&callbackURL=${callbackURL}`;
+	await options.emailVerification.sendVerificationEmail({
+		user,
+		url,
+		token
+	}, ctx);
+};
+const sendVerificationEmailRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.SEND_VERIFICATION_EMAIL,
+	method: "post",
+	path: "/send-verification-email",
+	description: "Send a verification email to the user",
+	request: (0, __faire_auth_core_factory.req)().bdy(sendVerificationEmailSchema).bld(),
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400).zod().bld()
+});
+const sendVerificationEmail = require_session.createEndpoint(sendVerificationEmailRoute, (options) => async (ctx) => {
+	const context = ctx.get("context");
+	if (!options.emailVerification?.sendVerificationEmail) {
+		context.logger.error("Verification email isn't enabled.");
+		return ctx.render({
+			success: __faire_auth_core_static.False,
+			message: "Verification email isn't enabled"
+		}, 400);
+	}
+	const { email, callbackURL } = ctx.req.valid("json");
+	const session = await require_session.getSessionFromCtx(ctx);
+	if (session instanceof Response) {
+		const user = await context.internalAdapter.findUserByEmail(email);
+		if (!user) return ctx.render({ success: __faire_auth_core_static.True }, 200);
+		await sendVerificationEmailFn(ctx, user.user, callbackURL, options);
+		return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	}
+	if (session.user.emailVerified) return ctx.render({
+		success: __faire_auth_core_static.False,
+		message: "You can only send a verification email to an unverified email"
+	}, 400);
+	if (session.user.email !== email) return ctx.render({
+		success: __faire_auth_core_static.False,
+		message: "You can only send a verification email to your own email"
+	}, 400);
+	await sendVerificationEmailFn(ctx, session.user, callbackURL, options);
+	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+});
+const verifyEmailRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.VERIFY_EMAIL,
+	method: "get",
+	path: "/verify-email",
+	description: "Verify the email of the user",
+	middleware: [require_origin_check.originCheck((ctx) => ctx.req.query("callbackURL")), tokenCheck((ctx) => ctx.req.query("token"), verifyEmailTokenSchema)],
+	request: (0, __faire_auth_core_factory.req)().qry(verifyEmailQuerySchema).bld(),
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.TOKEN_USER].default).err(401, "Invalid or expired token").err(500).rdr("Redirect to callback URL").zod().bld()
+});
+const verifyEmail = require_session.createEndpoint(verifyEmailRoute, (options) => async (ctx) => {
+	const { callbackURL } = ctx.req.valid("query");
+	const context = ctx.get("context");
+	const parsed = ctx.get("token");
+	const redirectOnError = (error) => {
+		if (callbackURL) {
+			if (callbackURL.includes("?")) return ctx.redirect(`${callbackURL}&error=${error}`, 302);
+			return ctx.redirect(`${callbackURL}?error=${error}`, 302);
+		}
+		return ctx.render({
+			success: __faire_auth_core_static.False,
+			code: error.toUpperCase(),
+			message: (0, __faire_auth_core_utils.capitalizeFirstLetter)(error.replaceAll("_", " "))
+		}, 401);
+	};
+	const user = await context.internalAdapter.findUserByEmail(parsed.email);
+	if (!user) return redirectOnError("user_not_found");
+	if (parsed.updateTo) {
+		const session = await require_session.getSessionFromCtx(ctx);
+		if (session instanceof Response || session.user.email !== parsed.email) return redirectOnError("unauthorized");
+		const updatedUser$1 = await context.internalAdapter.updateUserByEmail(parsed.email, {
+			email: parsed.updateTo,
+			emailVerified: false
+		});
+		if (updatedUser$1 == null) return ctx.render({
+			success: __faire_auth_core_static.False,
+			message: "Failed to update user"
+		}, 500);
+		const newToken = await createEmailVerificationToken(context.secret, parsed.updateTo);
+		if (options.emailVerification?.sendVerificationEmail) await options.emailVerification.sendVerificationEmail({
+			user: updatedUser$1,
+			url: `${context.baseURL}/verify-email?token=${newToken}&callbackURL=${callbackURL ?? encodeURIComponent("/")}`,
+			token: newToken
+		}, ctx);
+		await require_cookies.setSessionCookie(ctx, options, {
+			session: session.session,
+			user: {
+				...session.user,
+				email: parsed.updateTo,
+				emailVerified: false
+			}
+		});
+		if (callbackURL != null) return ctx.redirect(callbackURL, 302);
+		return ctx.render({
+			success: __faire_auth_core_static.True,
+			token: session.session.token,
+			user: updatedUser$1
+		}, 200);
+	}
+	if (options.emailVerification?.onEmailVerification) await options.emailVerification.onEmailVerification(user.user, ctx.req);
+	const updatedUser = await context.internalAdapter.updateUserByEmail(parsed.email, { emailVerified: true });
+	if (updatedUser == null) return ctx.render({
+		success: __faire_auth_core_static.False,
+		message: "Failed to update user"
+	}, 500);
+	if (options.emailVerification?.afterEmailVerification) await options.emailVerification.afterEmailVerification(updatedUser, ctx.req);
+	if (options.emailVerification?.autoSignInAfterVerification === true) {
+		const currentSession = await require_session.getSessionFromCtx(ctx);
+		if (currentSession instanceof Response || currentSession.user.email !== parsed.email) {
+			const session = await context.internalAdapter.createSession(user.user.id);
+			if (session == null) return ctx.render({
+				success: __faire_auth_core_static.False,
+				message: "Failed to create session"
+			}, 500);
+			await require_cookies.setSessionCookie(ctx, options, {
+				session,
+				user: {
+					...user.user,
+					emailVerified: true
+				}
+			});
+		} else await require_cookies.setSessionCookie(ctx, options, {
+			session: currentSession.session,
+			user: {
+				...currentSession.user,
+				emailVerified: true
+			}
+		});
+	}
+	if (callbackURL != null) return ctx.redirect(callbackURL, 302);
+	return ctx.render({ success: __faire_auth_core_static.False }, 200);
+});
+
+//#endregion
+Object.defineProperty(exports, 'createEmailVerificationToken', {
+  enumerable: true,
+  get: function () {
+    return createEmailVerificationToken;
+  }
+});
+Object.defineProperty(exports, 'sendVerificationEmail', {
+  enumerable: true,
+  get: function () {
+    return sendVerificationEmail;
+  }
+});
+Object.defineProperty(exports, 'verifyEmail', {
+  enumerable: true,
+  get: function () {
+    return verifyEmail;
+  }
+});

package/dist/email-verification-CWhj2qfb.mjs

@@ -0,0 +1,228 @@
+import { n as crypto_exports } from "./crypto-CyQRFtkq.mjs";
+import { y as setSessionCookie } from "./cookies-Ch1JfQIz.mjs";
+import { r as createMiddleware } from "./middleware-CE6OhDkq.mjs";
+import { f as createEndpoint, r as getSessionFromCtx } from "./session-rH8ougDl.mjs";
+import { n as originCheck } from "./origin-check-8Gajklvh.mjs";
+import { callbackURLSchema, createRoute, emailSchema, req, res } from "@faire-auth/core/factory";
+import { Definitions, False, Routes, SCHEMAS, True } from "@faire-auth/core/static";
+import { capitalizeFirstLetter } from "@faire-auth/core/utils";
+import * as z$1 from "zod";
+import { jwtVerify } from "jose";
+import { JWTExpired } from "jose/errors";
+
+//#region src/api/schema/email-verification.ts
+const sendVerificationEmailSchema = z$1.object({
+	email: emailSchema.openapi({ description: "The email to send the verification email to" }),
+	callbackURL: callbackURLSchema(true).openapi({ description: "The URL to use for email verification callback" })
+});
+const verifyEmailQuerySchema = z$1.object({
+	token: z$1.string().openapi({ description: "The token to verify the email" }),
+	callbackURL: callbackURLSchema(true).openapi({ description: "The URL to redirect to after email verification" })
+});
+const verifyEmailTokenSchema = z$1.object({
+	email: emailSchema,
+	updateTo: z$1.string().optional()
+});
+
+//#endregion
+//#region src/api/middleware/token-check.ts
+const onError = async (ctx, error) => {
+	let code;
+	if (error === "missing_token") code = 400;
+	else code = 401;
+	const url = ctx.req.query("callbackURL");
+	if (url) {
+		if (url.includes("?")) return ctx.redirect(`${url}&error=${error}`, 302);
+		return ctx.redirect(`${url}?error=${error}`, 302);
+	}
+	return ctx.render({
+		success: False,
+		code: error.toUpperCase(),
+		message: capitalizeFirstLetter(error.replaceAll("_", " "))
+	}, code);
+};
+const verifyToken = async (token, context) => {
+	let jwt;
+	try {
+		jwt = await jwtVerify(token, new TextEncoder().encode(context.secret), { algorithms: ["HS256"] });
+	} catch (e) {
+		if (e instanceof JWTExpired) return "token_expired";
+		return "invalid_token";
+	}
+	return jwt;
+};
+/**
+* Validates token against context secret.
+* @template V - The context variables type.
+* @param getValue - Function to get the token from the context.
+* @returns The middleware function.
+*/
+const tokenCheck = (getValue, schema) => createMiddleware()(async (ctx, next) => {
+	const token = await getValue(ctx);
+	if (!token) return onError(ctx, "missing_token");
+	const res$1 = await verifyToken(token, ctx.get("context"));
+	if (typeof res$1 === "string") return onError(ctx, res$1);
+	const dat = await schema.safeParseAsync(res$1.payload);
+	if (dat.success === false) return onError(ctx, "invalid_token");
+	ctx.set("token", dat.data);
+	return await next();
+});
+
+//#endregion
+//#region src/api/routes/email-verification.ts
+const createEmailVerificationToken = async (secret, email, updateTo, expiresIn = 3600) => {
+	return await (0, crypto_exports.signJWT)({
+		email: email.toLowerCase(),
+		updateTo
+	}, secret, expiresIn);
+};
+/**
+* A function to send a verification email to the user
+*/
+const sendVerificationEmailFn = async (ctx, user, callbackURL = encodeURIComponent("/"), options) => {
+	const context = ctx.get("context");
+	if (!options?.emailVerification?.sendVerificationEmail) {
+		context.logger.error("Verification email isn't enabled.");
+		return ctx.render({
+			success: False,
+			message: "Verification email isn't enabled"
+		}, 400);
+	}
+	const token = await createEmailVerificationToken(context.secret, user.email, void 0, options.emailVerification.expiresIn);
+	const url = `${context.baseURL}/verify-email?token=${token}&callbackURL=${callbackURL}`;
+	await options.emailVerification.sendVerificationEmail({
+		user,
+		url,
+		token
+	}, ctx);
+};
+const sendVerificationEmailRoute = createRoute({
+	operationId: Routes.SEND_VERIFICATION_EMAIL,
+	method: "post",
+	path: "/send-verification-email",
+	description: "Send a verification email to the user",
+	request: req().bdy(sendVerificationEmailSchema).bld(),
+	responses: res(SCHEMAS[Definitions.SUCCESS].default).err(400).zod().bld()
+});
+const sendVerificationEmail = createEndpoint(sendVerificationEmailRoute, (options) => async (ctx) => {
+	const context = ctx.get("context");
+	if (!options.emailVerification?.sendVerificationEmail) {
+		context.logger.error("Verification email isn't enabled.");
+		return ctx.render({
+			success: False,
+			message: "Verification email isn't enabled"
+		}, 400);
+	}
+	const { email, callbackURL } = ctx.req.valid("json");
+	const session = await getSessionFromCtx(ctx);
+	if (session instanceof Response) {
+		const user = await context.internalAdapter.findUserByEmail(email);
+		if (!user) return ctx.render({ success: True }, 200);
+		await sendVerificationEmailFn(ctx, user.user, callbackURL, options);
+		return ctx.render({ success: True }, 200);
+	}
+	if (session.user.emailVerified) return ctx.render({
+		success: False,
+		message: "You can only send a verification email to an unverified email"
+	}, 400);
+	if (session.user.email !== email) return ctx.render({
+		success: False,
+		message: "You can only send a verification email to your own email"
+	}, 400);
+	await sendVerificationEmailFn(ctx, session.user, callbackURL, options);
+	return ctx.render({ success: True }, 200);
+});
+const verifyEmailRoute = createRoute({
+	operationId: Routes.VERIFY_EMAIL,
+	method: "get",
+	path: "/verify-email",
+	description: "Verify the email of the user",
+	middleware: [originCheck((ctx) => ctx.req.query("callbackURL")), tokenCheck((ctx) => ctx.req.query("token"), verifyEmailTokenSchema)],
+	request: req().qry(verifyEmailQuerySchema).bld(),
+	responses: res(SCHEMAS[Definitions.TOKEN_USER].default).err(401, "Invalid or expired token").err(500).rdr("Redirect to callback URL").zod().bld()
+});
+const verifyEmail = createEndpoint(verifyEmailRoute, (options) => async (ctx) => {
+	const { callbackURL } = ctx.req.valid("query");
+	const context = ctx.get("context");
+	const parsed = ctx.get("token");
+	const redirectOnError = (error) => {
+		if (callbackURL) {
+			if (callbackURL.includes("?")) return ctx.redirect(`${callbackURL}&error=${error}`, 302);
+			return ctx.redirect(`${callbackURL}?error=${error}`, 302);
+		}
+		return ctx.render({
+			success: False,
+			code: error.toUpperCase(),
+			message: capitalizeFirstLetter(error.replaceAll("_", " "))
+		}, 401);
+	};
+	const user = await context.internalAdapter.findUserByEmail(parsed.email);
+	if (!user) return redirectOnError("user_not_found");
+	if (parsed.updateTo) {
+		const session = await getSessionFromCtx(ctx);
+		if (session instanceof Response || session.user.email !== parsed.email) return redirectOnError("unauthorized");
+		const updatedUser$1 = await context.internalAdapter.updateUserByEmail(parsed.email, {
+			email: parsed.updateTo,
+			emailVerified: false
+		});
+		if (updatedUser$1 == null) return ctx.render({
+			success: False,
+			message: "Failed to update user"
+		}, 500);
+		const newToken = await createEmailVerificationToken(context.secret, parsed.updateTo);
+		if (options.emailVerification?.sendVerificationEmail) await options.emailVerification.sendVerificationEmail({
+			user: updatedUser$1,
+			url: `${context.baseURL}/verify-email?token=${newToken}&callbackURL=${callbackURL ?? encodeURIComponent("/")}`,
+			token: newToken
+		}, ctx);
+		await setSessionCookie(ctx, options, {
+			session: session.session,
+			user: {
+				...session.user,
+				email: parsed.updateTo,
+				emailVerified: false
+			}
+		});
+		if (callbackURL != null) return ctx.redirect(callbackURL, 302);
+		return ctx.render({
+			success: True,
+			token: session.session.token,
+			user: updatedUser$1
+		}, 200);
+	}
+	if (options.emailVerification?.onEmailVerification) await options.emailVerification.onEmailVerification(user.user, ctx.req);
+	const updatedUser = await context.internalAdapter.updateUserByEmail(parsed.email, { emailVerified: true });
+	if (updatedUser == null) return ctx.render({
+		success: False,
+		message: "Failed to update user"
+	}, 500);
+	if (options.emailVerification?.afterEmailVerification) await options.emailVerification.afterEmailVerification(updatedUser, ctx.req);
+	if (options.emailVerification?.autoSignInAfterVerification === true) {
+		const currentSession = await getSessionFromCtx(ctx);
+		if (currentSession instanceof Response || currentSession.user.email !== parsed.email) {
+			const session = await context.internalAdapter.createSession(user.user.id);
+			if (session == null) return ctx.render({
+				success: False,
+				message: "Failed to create session"
+			}, 500);
+			await setSessionCookie(ctx, options, {
+				session,
+				user: {
+					...user.user,
+					emailVerified: true
+				}
+			});
+		} else await setSessionCookie(ctx, options, {
+			session: currentSession.session,
+			user: {
+				...currentSession.user,
+				emailVerified: true
+			}
+		});
+	}
+	if (callbackURL != null) return ctx.redirect(callbackURL, 302);
+	return ctx.render({ success: False }, 200);
+});
+
+//#endregion
+export { sendVerificationEmail as n, verifyEmail as r, createEmailVerificationToken as t };