faire-auth 1.0.0

package/dist/session-rH8ougDl.mjs

@@ -0,0 +1,538 @@
+import { t as contextStorage } from "./hono-CoKYWnXA.mjs";
+import { t as safeJSONParse } from "./json-B1v2qRTQ.mjs";
+import { n as cookies_exports, o as deleteSessionCookie, v as setCookieCache, y as setSessionCookie } from "./cookies-Ch1JfQIz.mjs";
+import { t as logged_default } from "./logged-CyGfp8_H.mjs";
+import { t as getBaseURL } from "./url-BoUuoIwZ.mjs";
+import { r as createMiddleware, t as createErrorHandler } from "./middleware-CE6OhDkq.mjs";
+import { isTest, logger } from "@faire-auth/core/env";
+import { APIError, BASE_ERROR_CODES } from "@faire-auth/core/error";
+import { buildRouteBundle, createRoute, createRouteAppWrapper, initRenderer, req, res } from "@faire-auth/core/factory";
+import { Definitions, False, Routes, SCHEMAS, True, isPromise } from "@faire-auth/core/static";
+import { getDate, isContextLike, isExecOpts, withOverlays } from "@faire-auth/core/utils";
+import { base64Url, binary, createHMAC } from "@faire-auth/core/datatypes";
+import { HTTPException } from "hono/http-exception";
+import * as z$1 from "zod";
+import { looseSessionSchema, looseUserSchema } from "@faire-auth/core/db";
+
+//#region src/api/middleware/context.ts
+/**
+* Initializes the context middleware.
+* @template O - The options type.
+* @param options - The FaireAuth options.
+* @param context - The auth context.
+* @returns The middleware function.
+*/
+const initContextMiddleware = (options, context, api) => createMiddleware()(async (ctx, next) => {
+	ctx.set("context", context);
+	ctx.set("api", api);
+	ctx.set("path", ctx.req.path.slice((options.basePath ?? "/api/auth").length));
+	return await next();
+});
+
+//#endregion
+//#region src/api/middleware/hooks.ts
+const runHooks = async (ctx, hooks) => {
+	let response = void 0;
+	for (const hook of hooks) if (hook.matcher(ctx)) try {
+		const maybePromise = hook.handler(ctx);
+		const result = isPromise(maybePromise) ? await maybePromise : maybePromise;
+		if (result instanceof Response) response = result;
+	} catch (error) {
+		ctx.error = error;
+	}
+	return response;
+};
+const getHooks = (options) => {
+	const beforeHooks = [];
+	const afterHooks = [];
+	if (options.hooks?.before != null) beforeHooks.push({
+		matcher: () => true,
+		handler: options.hooks.before(options)
+	});
+	if (options.hooks?.after != null) afterHooks.push({
+		matcher: () => true,
+		handler: options.hooks.after(options)
+	});
+	options.plugins?.forEach((p) => {
+		p.hooks?.before?.forEach((h) => beforeHooks.push({
+			matcher: h.matcher,
+			handler: h.handler(options)
+		}));
+		p.hooks?.after?.forEach((h) => afterHooks.push({
+			matcher: h.matcher,
+			handler: h.handler(options)
+		}));
+	});
+	return {
+		beforeHooks,
+		afterHooks
+	};
+};
+/**
+* Initializes the hooks middleware.
+* @template O - The options type.
+* @param options - The FaireAuth options.
+* @returns The middleware function.
+*/
+const initHooksMiddleware = (options) => {
+	const { beforeHooks, afterHooks } = getHooks(options);
+	return createMiddleware()(async (ctx, next) => {
+		const before = await runHooks(ctx, beforeHooks);
+		if (before instanceof Response) return before;
+		await next();
+		const after = await runHooks(ctx, afterHooks);
+		if (after instanceof Response) ctx.res = after;
+	});
+};
+
+//#endregion
+//#region src/api/middleware/on-error.ts
+/**
+* Initializes the error handler.
+* @param options - The FaireAuth options.
+* @returns The error handler function.
+*/
+const initErrorHandler = (options) => createErrorHandler()(async (e, ctx) => {
+	const ret = ctx.finalized === true ? ctx.res : e instanceof Response ? e : e instanceof HTTPException ? e.getResponse() : ctx.json({
+		success: False,
+		...options.onAPIError?.exposeMessage === true && { message: e.message }
+	}, 500);
+	if (e instanceof APIError && e.statusText === "FOUND") return ret;
+	if (options.onAPIError?.throw === true) throw e;
+	if (options.onAPIError?.onError) {
+		const res$1 = options.onAPIError.onError(e, ctx);
+		if (isPromise(res$1)) await res$1;
+		return ret;
+	}
+	const optLogLevel = options.logger?.level;
+	const critLog = ctx.get("context")?.logger ?? console;
+	const log = optLogLevel === "error" || optLogLevel === "warn" || optLogLevel === "debug" ? logger : void 0;
+	if (options.logger?.disabled !== true) {
+		if (e != null && typeof e === "object" && "message" in e && typeof e.message === "string") {
+			if (e.message.includes("no column") || e.message.includes("column") || e.message.includes("relation") || e.message.includes("table") || e.message.includes("does not exist")) {
+				critLog.error(e.message);
+				return ret;
+			}
+		}
+		if (e instanceof APIError) {
+			if (e.statusText === "INTERNAL_SERVER_ERROR") critLog.error(e.statusText, e);
+			log?.error(e.message);
+		} else critLog.error(e != null && typeof e === "object" && "name" in e ? e.name : "", e);
+	}
+	return ret;
+});
+
+//#endregion
+//#region src/api/middleware/server-api.ts
+/**
+* Middleware that sets a flag indicating the route was called from the server-side API.
+* This should only be used with localApp in createEndpoint to provide permissions depth.
+*/
+const serverApiMiddleware = createMiddleware()(async (ctx, next) => {
+	ctx.set("isServer", true);
+	return await next();
+});
+
+//#endregion
+//#region src/utils/hono.ts
+const createDefaultExecutionCtx = (ctx) => {
+	Object.defineProperty(ctx, "executionCtx", {
+		get: () => ({
+			waitUntil: (promise) => ctx.get("toAwait").push(promise),
+			passThroughOnException: () => {},
+			props: {}
+		}),
+		configurable: true,
+		enumerable: true
+	});
+};
+
+//#endregion
+//#region src/api/middleware/set-execution-ctx.ts
+/**
+* Sets the default execution context if not already present.
+* Manages promises to await after the middleware chain.
+*/
+const setDefaultExecutionCtx = createMiddleware()(async (ctx, next) => {
+	ctx.set("toAwait", []);
+	let hasDefaultExecutionCtx = false;
+	try {
+		ctx.executionCtx;
+	} catch {
+		createDefaultExecutionCtx(ctx);
+		hasDefaultExecutionCtx = true;
+	}
+	await next();
+	if (hasDefaultExecutionCtx === true) await Promise.allSettled(ctx.get("toAwait"));
+});
+
+//#endregion
+//#region src/api/middleware/set-renderer.ts
+/**
+* Sets the renderer for the context.
+*
+* @todo `options.hono?.advanced?.cbor === true ? cborRespond : ctx.json`
+*/
+const setRenderer = createMiddleware()(async (ctx, next) => {
+	ctx.setRenderer(initRenderer(ctx));
+	return await next();
+});
+
+//#endregion
+//#region src/api/factory/endpoint.ts
+/**
+* Creates an auth endpoint.
+* @template C - The route config type.
+* @param config - The route configuration.
+* @param handler - The route handler function.
+* @param hook - Optional route hook.
+* @returns The auth endpoint function.
+*/
+const createEndpoint = (config, handler, hook) => {
+	let bundle = null;
+	return ((options) => {
+		const resolvedHandler = handler(options);
+		let localApp = null;
+		const execute = logged_default.wrap(async (...args) => {
+			if (!bundle) throw new Error(`${config.operationId} config() must be called before using execute()!`);
+			const [inputOrCtx, maybeCtx] = args;
+			const { input, ctx, opts } = isContextLike(inputOrCtx) ? {
+				input: void 0,
+				ctx: inputOrCtx,
+				opts: void 0
+			} : isContextLike(maybeCtx) ? {
+				input: inputOrCtx,
+				ctx: maybeCtx,
+				opts: void 0
+			} : isExecOpts(inputOrCtx) ? {
+				input: void 0,
+				ctx: void 0,
+				opts: inputOrCtx
+			} : {
+				input: inputOrCtx,
+				ctx: void 0,
+				opts: isExecOpts(maybeCtx) ? maybeCtx : void 0
+			};
+			if (ctx == null) {
+				if (localApp == null) throw new Error(`${config.operationId} handler() must be called before using server-side execute()!`);
+				const res$1 = localApp.fetch(new Request(...bundle.builder(input, opts?.headers)));
+				if (opts?.returnHeaders === true) return res$1 instanceof Response ? bundle.parser(res$1).then((r) => ({
+					headers: res$1.headers,
+					response: r
+				})) : res$1.then((re) => bundle.parser(re).then((r) => ({
+					headers: re.headers,
+					response: r
+				})));
+				if (opts?.asResponse === true) return res$1;
+				return Promise.resolve(res$1).then((r) => bundle.parser(r));
+			}
+			const out = await resolvedHandler(withOverlays(ctx, input, config), async () => {
+				throw new Error("next() called in manual execution when response was expected");
+			});
+			return bundle.parser(out);
+		}, config.operationId, "immediate");
+		execute.toArgs = (builtSchemas, context, api, routeHook = hook) => {
+			if (!bundle) bundle = buildRouteBundle(config, resolvedHandler, getBaseURL(options.baseURL, options.basePath), options, builtSchemas, routeHook, context.logger);
+			else if (!isTest()) context.logger.warn(`${bundle.resolvedConfig.operationId} config() already initialized`);
+			if (!localApp) localApp = createRouteAppWrapper(bundle.routeApp, [
+				serverApiMiddleware,
+				setDefaultExecutionCtx,
+				setRenderer,
+				initContextMiddleware(options, context, api),
+				contextStorage(),
+				initHooksMiddleware(options)
+			], initErrorHandler(options), options.basePath);
+			else if (!isTest()) context.logger.warn(`${config.operationId} handler() was called when already initialized`);
+			return [
+				bundle.resolvedConfig,
+				resolvedHandler,
+				routeHook
+			];
+		};
+		return execute;
+	});
+};
+const createAPI = (endpoints) => endpoints;
+
+//#endregion
+//#region src/api/schema/session.ts
+const getSessionQuerySchema = z$1.object({
+	disableCookieCache: z$1.boolean().or(z$1.string().transform((v) => v === "true")).openapi({
+		param: {
+			in: "query",
+			name: "disableCookieCache"
+		},
+		description: "Disable cookie cache and fetch session from database"
+	}),
+	disableRefresh: z$1.boolean().or(z$1.string().transform((v) => v === "true")).openapi({
+		param: {
+			in: "query",
+			name: "disableRefresh"
+		},
+		description: "Disable session refresh. Useful for checking session status, without updating the session"
+	})
+}).partial();
+const revokeSessionSchema = z$1.object({ token: z$1.string().openapi({ description: "The token to revoke" }) });
+
+//#endregion
+//#region src/api/routes/session.ts
+const getSessionRoute = createRoute({
+	operationId: Routes.GET_SESSION,
+	method: "get",
+	path: "/get-session",
+	description: "Get the current session",
+	request: req().qry(getSessionQuerySchema).bld(),
+	responses: res(SCHEMAS[Definitions.SESSION_USER].default).err(401, "Failed to get session or expired").zod().err(500, "Unexpected Error").bld()
+});
+const getSession = createEndpoint(getSessionRoute, (options) => async (ctx) => {
+	const { disableCookieCache, disableRefresh } = ctx.req.valid("query");
+	const context = ctx.get("context");
+	try {
+		const sessionCookieToken = await (0, cookies_exports.getSignedCookie)(ctx, context.secret, context.authCookies.sessionToken.name);
+		if (sessionCookieToken == null) return ctx.render({
+			success: False,
+			message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+		}, 401);
+		if (sessionCookieToken === false) return ctx.render({
+			success: False,
+			message: BASE_ERROR_CODES.SESSION_EXPIRED
+		}, 401);
+		const sessionDataCookie = (0, cookies_exports.getCookie)(ctx, context.authCookies.sessionData.name);
+		const sessionDataPayload = sessionDataCookie != null ? safeJSONParse(binary.decode(base64Url.decode(sessionDataCookie))) : null;
+		if (sessionDataPayload) {
+			if (!await createHMAC("SHA-256", "base64urlnopad").verify(context.secret, JSON.stringify({
+				...sessionDataPayload.session,
+				expiresAt: sessionDataPayload.expiresAt
+			}), sessionDataPayload.signature)) {
+				(0, cookies_exports.deleteCookie)(ctx, context.authCookies.sessionData.name, context.authCookies.sessionData.options);
+				return ctx.render({
+					success: False,
+					message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+				}, 401);
+			}
+		}
+		const dontRememberMe = await (0, cookies_exports.getSignedCookie)(ctx, context.secret, context.authCookies.dontRememberToken.name);
+		/**
+		* If session data is present in the cookie, return it
+		*/
+		if (sessionDataPayload?.session && options.session?.cookieCache?.enabled === true && disableCookieCache !== true) {
+			const { session: session$1 } = sessionDataPayload;
+			if (!(session$1.session.createdAt instanceof Date) || !(session$1.session.updatedAt instanceof Date) || !(session$1.session.expiresAt instanceof Date) || !(session$1.user.createdAt instanceof Date) || !(session$1.user.updatedAt instanceof Date)) console.warn("not date ln 122");
+			if (!(sessionDataPayload.expiresAt < Date.now() || session$1.session.expiresAt < /* @__PURE__ */ new Date())) {
+				ctx.set("session", session$1);
+				return ctx.render(session$1, 200);
+			}
+			(0, cookies_exports.deleteCookie)(ctx, context.authCookies.sessionData.name, context.authCookies.sessionData.options);
+		}
+		const session = await context.internalAdapter.findSession(sessionCookieToken);
+		ctx.set("session", session);
+		if (!session || session.session.expiresAt < /* @__PURE__ */ new Date()) {
+			deleteSessionCookie(ctx);
+			if (session) {
+				await context.internalAdapter.deleteSession(session.session.token);
+				return ctx.render({
+					success: False,
+					message: BASE_ERROR_CODES.SESSION_EXPIRED
+				}, 401);
+			}
+			return ctx.render({
+				success: False,
+				message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+			}, 401);
+		}
+		/**
+		* We don't need to update the session if the user doesn't want to be remembered
+		* or if the session refresh is disabled
+		*/
+		if (dontRememberMe != null && dontRememberMe !== false || disableRefresh === true) return ctx.render(session, 200);
+		const { expiresIn, updateAge } = context.sessionConfig;
+		if (session.session.expiresAt.valueOf() - expiresIn * 1e3 + updateAge * 1e3 <= Date.now() && !options.session?.disableSessionRefresh) {
+			const updatedSession = await context.internalAdapter.updateSession(session.session.token, {
+				expiresAt: getDate(context.sessionConfig.expiresIn, "sec"),
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+			if (updatedSession == null) {
+				/**
+				* Handle case where session update fails (e.g., concurrent deletion)
+				*/
+				deleteSessionCookie(ctx);
+				return ctx.render({
+					success: False,
+					message: BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
+				}, 401);
+			}
+			const maxAge = (updatedSession.expiresAt.valueOf() - Date.now()) / 1e3;
+			await setSessionCookie(ctx, options, {
+				session: updatedSession,
+				user: session.user
+			}, false, { maxAge });
+			if (!(updatedSession.createdAt instanceof Date) || !(updatedSession.updatedAt instanceof Date) || !(updatedSession.expiresAt instanceof Date) || !(session.user.createdAt instanceof Date) || !(session.user.updatedAt instanceof Date)) console.warn("not date ln 220");
+			return ctx.render({
+				session: updatedSession,
+				user: session.user
+			}, 200);
+		}
+		if (options.session?.cookieCache?.enabled === true) await setCookieCache(ctx, options, session, dontRememberMe);
+		if (!(session.session.createdAt instanceof Date) || !(session.session.updatedAt instanceof Date) || !(session.session.expiresAt instanceof Date) || !(session.user.createdAt instanceof Date) || !(session.user.updatedAt instanceof Date)) console.warn("not date ln 231");
+		return ctx.render(session, 200);
+	} catch (error) {
+		context.logger.error("INTERNAL_SERVER_ERROR", error);
+		return ctx.render({
+			success: False,
+			message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+		}, 500);
+	}
+});
+const getSessionFromCtx = async (ctx, config) => {
+	const session = ctx.get("session");
+	if (session) return session;
+	const newSession = await ctx.get("api").getSession({ query: { ...config && config } }, ctx).then(async (s) => s.success === true ? {
+		success: true,
+		data: {
+			session: looseSessionSchema.parse(s.data.session),
+			user: looseUserSchema.parse(s.data.user)
+		}
+	} : s);
+	if (newSession.success === false) return ctx.render(session ?? {
+		success: False,
+		message: BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+	}, 401);
+	ctx.set("session", newSession.data);
+	return newSession.data;
+};
+/**
+* The middleware forces the endpoint to require a valid session.
+*/
+const sessionMiddleware = () => createMiddleware()(async (ctx, next) => {
+	const session = await getSessionFromCtx(ctx);
+	if (session instanceof Response) return session;
+	return await next();
+});
+/**
+* This middleware forces the endpoint to require a valid session and ignores cookie cache.
+* This should be used for sensitive operations like password changes, account deletion, etc.
+* to ensure that revoked sessions cannot be used even if they're still cached in cookies.
+*/
+const sensitiveSessionMiddleware = createMiddleware()(async (ctx, next) => {
+	const session = await getSessionFromCtx(ctx, { disableCookieCache: true });
+	if (session instanceof Response) return session;
+	return await next();
+});
+/**
+* This middleware allows you to call the endpoint on the client if session is valid.
+* However, if called on the server, no session is required.
+*/
+const requestOnlySessionMiddleware = createMiddleware()(async (ctx, next) => {
+	const session = await getSessionFromCtx(ctx);
+	if (session instanceof Response && ctx.get("isServer") !== true) return session;
+	return await next();
+});
+/**
+* This middleware forces the endpoint to require a valid session,
+* as well as making sure the session is fresh before proceeding.
+*
+* Session freshness check will be skipped if the session config's freshAge
+* is set to 0
+*/
+const freshSessionMiddleware = createMiddleware()(async (ctx, next) => {
+	const session = await getSessionFromCtx(ctx);
+	if (session instanceof Response) return session;
+	const context = ctx.get("context");
+	if (context.sessionConfig.freshAge === 0) return await next();
+	const lastUpdated = (session.session.updatedAt ?? session.session.createdAt).valueOf();
+	if (!(Date.now() - lastUpdated < context.sessionConfig.freshAge * 1e3)) return ctx.render({
+		success: False,
+		message: "Session is not fresh"
+	}, 403);
+	return await next();
+});
+const listSessionsRoute = createRoute({
+	operationId: Routes.LIST_SESSIONS,
+	method: "get",
+	path: "/list-sessions",
+	description: "List all active sessions for the user",
+	middleware: [sessionMiddleware()],
+	responses: res(SCHEMAS[Definitions.SESSIONS_LIST].default).err(500).bld()
+});
+const listSessions = createEndpoint(listSessionsRoute, (_options) => async (ctx) => {
+	try {
+		const activeSessions = (await ctx.get("context").internalAdapter.listSessions(ctx.get("session").user.id)).filter((s) => s.expiresAt > /* @__PURE__ */ new Date());
+		return ctx.render(activeSessions, 200);
+	} catch (e) {
+		ctx.get("context").logger.error(e instanceof Error ? e.message : String(e), e);
+		return ctx.render({
+			success: False,
+			message: "Internal server error"
+		}, 500);
+	}
+});
+const revokeSessionRoute = createRoute({
+	operationId: Routes.REVOKE_SESSION,
+	method: "post",
+	path: "/revoke-session",
+	description: "Revoke a single session",
+	middleware: [sensitiveSessionMiddleware],
+	request: req().bdy(revokeSessionSchema).bld(),
+	responses: res(SCHEMAS[Definitions.SUCCESS].default).zod().err(400).err(401).err(500).bld()
+});
+const revokeSession = createEndpoint(revokeSessionRoute, (_options) => async (ctx) => {
+	const context = ctx.get("context");
+	const session = ctx.get("session");
+	const { token } = ctx.req.valid("json");
+	const foundSession = await context.internalAdapter.findSession(token);
+	if (!foundSession) return ctx.render({
+		success: False,
+		message: "Session not found"
+	}, 400);
+	if (foundSession.session.userId !== session.user.id) return ctx.render({ success: False }, 401);
+	try {
+		await context.internalAdapter.deleteSession(token);
+	} catch (error) {
+		context.logger.error(error != null && typeof error === "object" && "name" in error ? String(error.name) : "Unknown Error", error);
+		return ctx.render({
+			success: False,
+			message: "Internal server error"
+		}, 500);
+	}
+	return ctx.render({ success: True }, 200);
+});
+const revokeSessionsRoute = createRoute({
+	operationId: Routes.REVOKE_SESSIONS,
+	method: "post",
+	path: "/revoke-sessions",
+	description: "Revoke all sessions for the user",
+	middleware: [sensitiveSessionMiddleware],
+	responses: res(SCHEMAS[Definitions.SUCCESS].default).err(500).bld()
+});
+const revokeSessions = createEndpoint(revokeSessionsRoute, (_options) => async (ctx) => {
+	const context = ctx.get("context");
+	const session = ctx.get("session");
+	try {
+		await context.internalAdapter.deleteSessions(session.user.id);
+	} catch (error) {
+		context.logger.error(error != null && typeof error === "object" && "name" in error ? String(error.name) : "Unknown Error", error);
+		return ctx.render({
+			success: False,
+			message: "Internal server error"
+		}, 500);
+	}
+	return ctx.render({ success: True }, 200);
+});
+const revokeOtherSessionsRoute = createRoute({
+	operationId: Routes.REVOKE_OTHER_SESSIONS,
+	method: "post",
+	path: "/revoke-other-sessions",
+	description: "Revoke all other sessions for the user except the current one",
+	middleware: [sensitiveSessionMiddleware],
+	responses: res(SCHEMAS[Definitions.SUCCESS].default).bld()
+});
+const revokeOtherSessions = createEndpoint(revokeOtherSessionsRoute, (_options) => async (ctx) => {
+	const context = ctx.get("context");
+	const session = ctx.get("session");
+	const otherSessions = (await context.internalAdapter.listSessions(session.user.id)).filter((session$1) => session$1.expiresAt > /* @__PURE__ */ new Date()).filter((sess) => sess.token !== session.session.token);
+	await Promise.all(otherSessions.map(async (session$1) => context.internalAdapter.deleteSession(session$1.token)));
+	return ctx.render({ success: True }, 200);
+});
+
+//#endregion
+export { initContextMiddleware as _, requestOnlySessionMiddleware as a, revokeSessions as c, createAPI as d, createEndpoint as f, initHooksMiddleware as g, initErrorHandler as h, listSessions as i, sensitiveSessionMiddleware as l, setDefaultExecutionCtx as m, getSession as n, revokeOtherSessions as o, setRenderer as p, getSessionFromCtx as r, revokeSession as s, freshSessionMiddleware as t, sessionMiddleware as u };

package/dist/social-providers/index.cjs

@@ -0,0 +1,10 @@
+const require_social_providers = require('../social-providers-DcFNUT0S.cjs');
+
+
+var __faire_auth_core_social_providers = require("@faire-auth/core/social-providers");
+Object.keys(__faire_auth_core_social_providers).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __faire_auth_core_social_providers[k]; }
+  });
+});

package/dist/social-providers/index.d.cts

@@ -0,0 +1,2 @@
+import "../index-B7SKyR_a.cjs";
+export * from "@faire-auth/core/social-providers";

package/dist/social-providers/index.d.mts

@@ -0,0 +1,2 @@
+import "../index-B5_0QTLg.mjs";
+export * from "@faire-auth/core/social-providers";

package/dist/social-providers/index.mjs

@@ -0,0 +1,5 @@
+import "../social-providers-DoYJhBe3.mjs";
+
+export * from "@faire-auth/core/social-providers"
+
+export {  };

package/dist/social-providers-DcFNUT0S.cjs

@@ -0,0 +1,13 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+
+//#region src/social-providers/index.ts
+var social_providers_exports = {};
+require_chunk.__reExport(social_providers_exports, require("@faire-auth/core/social-providers"));
+
+//#endregion
+Object.defineProperty(exports, 'social_providers_exports', {
+  enumerable: true,
+  get: function () {
+    return social_providers_exports;
+  }
+});

package/dist/social-providers-DoYJhBe3.mjs

@@ -0,0 +1,9 @@
+import { r as __reExport } from "./chunk-Ceigfy4P.mjs";
+
+//#region src/social-providers/index.ts
+var social_providers_exports = {};
+import * as import___faire_auth_core_social_providers from "@faire-auth/core/social-providers";
+__reExport(social_providers_exports, import___faire_auth_core_social_providers);
+
+//#endregion
+export { social_providers_exports as t };

package/dist/state--f7fwIGh.cjs

@@ -0,0 +1,99 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_crypto = require('./crypto-CcTxYH82.cjs');
+let __faire_auth_core_error = require("@faire-auth/core/error");
+let __faire_auth_core_factory = require("@faire-auth/core/factory");
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
+
+//#region src/oauth2/state.ts
+const generateState = async (ctx, link, options) => {
+	let { callbackURL, errorCallbackURL, newUserCallbackURL, requestSignUp } = ctx.req.valid("json");
+	callbackURL = callbackURL ?? options?.baseURL;
+	if (callbackURL == null) throw new __faire_auth_core_error.APIError("BAD_REQUEST", { message: "callbackURL or baseURL is required" });
+	const context = ctx.get("context");
+	const codeVerifier = (0, require_crypto.crypto_exports.generateRandomString)(128);
+	const state = (0, require_crypto.crypto_exports.generateRandomString)(32);
+	const data = JSON.stringify({
+		callbackURL,
+		codeVerifier,
+		...errorCallbackURL && { errorURL: errorCallbackURL },
+		...newUserCallbackURL && { newUserURL: newUserCallbackURL },
+		expiresAt: Date.now() + 600 * 1e3,
+		...link && { link },
+		...requestSignUp && { requestSignUp }
+	});
+	const expiresAt = /* @__PURE__ */ new Date();
+	expiresAt.setMinutes(expiresAt.getMinutes() + 10);
+	const verification = await context.internalAdapter.createVerificationValue({
+		value: data,
+		identifier: state,
+		expiresAt
+	});
+	if (verification == null) {
+		context.logger.error("Unable to create verification. Make sure the database adapter is properly working and there is a verification table in the database");
+		throw new __faire_auth_core_error.APIError("INTERNAL_SERVER_ERROR", { message: "Unable to create verification" });
+	}
+	return {
+		state: verification.identifier,
+		codeVerifier
+	};
+};
+const parsingSchema = zod.object({
+	callbackURL: zod.string(),
+	codeVerifier: zod.string(),
+	errorURL: zod.string().optional(),
+	newUserURL: zod.string().optional(),
+	expiresAt: zod.number(),
+	link: zod.object({
+		email: __faire_auth_core_factory.emailSchema,
+		userId: zod.coerce.string()
+	}).optional(),
+	requestSignUp: zod.boolean().optional()
+});
+const parseState = async (ctx, options) => {
+	let state;
+	try {
+		state = ctx.req.valid("json").state;
+	} catch {
+		state = ctx.req.valid("query").state;
+	}
+	const context = ctx.get("context");
+	const data = await context.internalAdapter.findVerificationValue(state);
+	if (data == null) {
+		context.logger.error("State Mismatch. Verification not found", { state });
+		const errorURL = options.onAPIError?.errorURL ?? `${context.baseURL}/error`;
+		return {
+			type: "redirect",
+			response: ctx.redirect(`${errorURL}?error=please_restart_the_process`, 302)
+		};
+	}
+	const parsedData = parsingSchema.parse(JSON.parse(data.value));
+	parsedData.errorURL ??= `${context.baseURL}/error`;
+	if (parsedData.expiresAt < Date.now()) {
+		await context.internalAdapter.deleteVerificationValue(data.id);
+		const errorURL = options.onAPIError?.errorURL ?? `${context.baseURL}/error`;
+		return {
+			type: "redirect",
+			response: ctx.redirect(`${errorURL}?error=please_restart_the_process`, 302)
+		};
+	}
+	await context.internalAdapter.deleteVerificationValue(data.id);
+	return {
+		type: "success",
+		data: parsedData
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'generateState', {
+  enumerable: true,
+  get: function () {
+    return generateState;
+  }
+});
+Object.defineProperty(exports, 'parseState', {
+  enumerable: true,
+  get: function () {
+    return parseState;
+  }
+});