faire-auth 1.0.0

package/dist/session-De9POJTW.cjs

@@ -0,0 +1,641 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_json = require('./json-CcJ2HjGo.cjs');
+const require_cookies = require('./cookies-B5xeA6i8.cjs');
+const require_logged = require('./logged-DQK3C64b.cjs');
+const require_url = require('./url-D2yvKaM7.cjs');
+const require_middleware = require('./middleware-CWvRH4EW.cjs');
+let __faire_auth_core_env = require("@faire-auth/core/env");
+let __faire_auth_core_error = require("@faire-auth/core/error");
+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 __faire_auth_core_datatypes = require("@faire-auth/core/datatypes");
+let hono_http_exception = require("hono/http-exception");
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
+let __faire_auth_core_db = require("@faire-auth/core/db");
+let hono_context_storage = require("hono/context-storage");
+
+//#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) => require_middleware.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 = (0, __faire_auth_core_static.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 require_middleware.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) => require_middleware.createErrorHandler()(async (e, ctx) => {
+	const ret = ctx.finalized === true ? ctx.res : e instanceof Response ? e : e instanceof hono_http_exception.HTTPException ? e.getResponse() : ctx.json({
+		success: __faire_auth_core_static.False,
+		...options.onAPIError?.exposeMessage === true && { message: e.message }
+	}, 500);
+	if (e instanceof __faire_auth_core_error.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 ((0, __faire_auth_core_static.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" ? __faire_auth_core_env.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 __faire_auth_core_error.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 = require_middleware.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 = require_middleware.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 = require_middleware.createMiddleware()(async (ctx, next) => {
+	ctx.setRenderer((0, __faire_auth_core_factory.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 = require_logged.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 } = (0, __faire_auth_core_utils.isContextLike)(inputOrCtx) ? {
+				input: void 0,
+				ctx: inputOrCtx,
+				opts: void 0
+			} : (0, __faire_auth_core_utils.isContextLike)(maybeCtx) ? {
+				input: inputOrCtx,
+				ctx: maybeCtx,
+				opts: void 0
+			} : (0, __faire_auth_core_utils.isExecOpts)(inputOrCtx) ? {
+				input: void 0,
+				ctx: void 0,
+				opts: inputOrCtx
+			} : {
+				input: inputOrCtx,
+				ctx: void 0,
+				opts: (0, __faire_auth_core_utils.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((0, __faire_auth_core_utils.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 = (0, __faire_auth_core_factory.buildRouteBundle)(config, resolvedHandler, require_url.getBaseURL(options.baseURL, options.basePath), options, builtSchemas, routeHook, context.logger);
+			else if (!(0, __faire_auth_core_env.isTest)()) context.logger.warn(`${bundle.resolvedConfig.operationId} config() already initialized`);
+			if (!localApp) localApp = (0, __faire_auth_core_factory.createRouteAppWrapper)(bundle.routeApp, [
+				serverApiMiddleware,
+				setDefaultExecutionCtx,
+				setRenderer,
+				initContextMiddleware(options, context, api),
+				(0, hono_context_storage.contextStorage)(),
+				initHooksMiddleware(options)
+			], initErrorHandler(options), options.basePath);
+			else if (!(0, __faire_auth_core_env.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 = zod.object({
+	disableCookieCache: zod.boolean().or(zod.string().transform((v) => v === "true")).openapi({
+		param: {
+			in: "query",
+			name: "disableCookieCache"
+		},
+		description: "Disable cookie cache and fetch session from database"
+	}),
+	disableRefresh: zod.boolean().or(zod.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 = zod.object({ token: zod.string().openapi({ description: "The token to revoke" }) });
+
+//#endregion
+//#region src/api/routes/session.ts
+const getSessionRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.GET_SESSION,
+	method: "get",
+	path: "/get-session",
+	description: "Get the current session",
+	request: (0, __faire_auth_core_factory.req)().qry(getSessionQuerySchema).bld(),
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.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, require_cookies.cookies_exports.getSignedCookie)(ctx, context.secret, context.authCookies.sessionToken.name);
+		if (sessionCookieToken == null) return ctx.render({
+			success: __faire_auth_core_static.False,
+			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+		}, 401);
+		if (sessionCookieToken === false) return ctx.render({
+			success: __faire_auth_core_static.False,
+			message: __faire_auth_core_error.BASE_ERROR_CODES.SESSION_EXPIRED
+		}, 401);
+		const sessionDataCookie = (0, require_cookies.cookies_exports.getCookie)(ctx, context.authCookies.sessionData.name);
+		const sessionDataPayload = sessionDataCookie != null ? require_json.safeJSONParse(__faire_auth_core_datatypes.binary.decode(__faire_auth_core_datatypes.base64Url.decode(sessionDataCookie))) : null;
+		if (sessionDataPayload) {
+			if (!await (0, __faire_auth_core_datatypes.createHMAC)("SHA-256", "base64urlnopad").verify(context.secret, JSON.stringify({
+				...sessionDataPayload.session,
+				expiresAt: sessionDataPayload.expiresAt
+			}), sessionDataPayload.signature)) {
+				(0, require_cookies.cookies_exports.deleteCookie)(ctx, context.authCookies.sessionData.name, context.authCookies.sessionData.options);
+				return ctx.render({
+					success: __faire_auth_core_static.False,
+					message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+				}, 401);
+			}
+		}
+		const dontRememberMe = await (0, require_cookies.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, require_cookies.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()) {
+			require_cookies.deleteSessionCookie(ctx);
+			if (session) {
+				await context.internalAdapter.deleteSession(session.session.token);
+				return ctx.render({
+					success: __faire_auth_core_static.False,
+					message: __faire_auth_core_error.BASE_ERROR_CODES.SESSION_EXPIRED
+				}, 401);
+			}
+			return ctx.render({
+				success: __faire_auth_core_static.False,
+				message: __faire_auth_core_error.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: (0, __faire_auth_core_utils.getDate)(context.sessionConfig.expiresIn, "sec"),
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+			if (updatedSession == null) {
+				/**
+				* Handle case where session update fails (e.g., concurrent deletion)
+				*/
+				require_cookies.deleteSessionCookie(ctx);
+				return ctx.render({
+					success: __faire_auth_core_static.False,
+					message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
+				}, 401);
+			}
+			const maxAge = (updatedSession.expiresAt.valueOf() - Date.now()) / 1e3;
+			await require_cookies.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 require_cookies.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: __faire_auth_core_static.False,
+			message: __faire_auth_core_error.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: __faire_auth_core_db.looseSessionSchema.parse(s.data.session),
+			user: __faire_auth_core_db.looseUserSchema.parse(s.data.user)
+		}
+	} : s);
+	if (newSession.success === false) return ctx.render(session ?? {
+		success: __faire_auth_core_static.False,
+		message: __faire_auth_core_error.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 = () => require_middleware.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 = require_middleware.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 = require_middleware.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 = require_middleware.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: __faire_auth_core_static.False,
+		message: "Session is not fresh"
+	}, 403);
+	return await next();
+});
+const listSessionsRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.LIST_SESSIONS,
+	method: "get",
+	path: "/list-sessions",
+	description: "List all active sessions for the user",
+	middleware: [sessionMiddleware()],
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.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: __faire_auth_core_static.False,
+			message: "Internal server error"
+		}, 500);
+	}
+});
+const revokeSessionRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.REVOKE_SESSION,
+	method: "post",
+	path: "/revoke-session",
+	description: "Revoke a single session",
+	middleware: [sensitiveSessionMiddleware],
+	request: (0, __faire_auth_core_factory.req)().bdy(revokeSessionSchema).bld(),
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.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: __faire_auth_core_static.False,
+		message: "Session not found"
+	}, 400);
+	if (foundSession.session.userId !== session.user.id) return ctx.render({ success: __faire_auth_core_static.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: __faire_auth_core_static.False,
+			message: "Internal server error"
+		}, 500);
+	}
+	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+});
+const revokeSessionsRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.Routes.REVOKE_SESSIONS,
+	method: "post",
+	path: "/revoke-sessions",
+	description: "Revoke all sessions for the user",
+	middleware: [sensitiveSessionMiddleware],
+	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.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: __faire_auth_core_static.False,
+			message: "Internal server error"
+		}, 500);
+	}
+	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+});
+const revokeOtherSessionsRoute = (0, __faire_auth_core_factory.createRoute)({
+	operationId: __faire_auth_core_static.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: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.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: __faire_auth_core_static.True }, 200);
+});
+
+//#endregion
+Object.defineProperty(exports, 'createAPI', {
+  enumerable: true,
+  get: function () {
+    return createAPI;
+  }
+});
+Object.defineProperty(exports, 'createEndpoint', {
+  enumerable: true,
+  get: function () {
+    return createEndpoint;
+  }
+});
+Object.defineProperty(exports, 'freshSessionMiddleware', {
+  enumerable: true,
+  get: function () {
+    return freshSessionMiddleware;
+  }
+});
+Object.defineProperty(exports, 'getSession', {
+  enumerable: true,
+  get: function () {
+    return getSession;
+  }
+});
+Object.defineProperty(exports, 'getSessionFromCtx', {
+  enumerable: true,
+  get: function () {
+    return getSessionFromCtx;
+  }
+});
+Object.defineProperty(exports, 'initContextMiddleware', {
+  enumerable: true,
+  get: function () {
+    return initContextMiddleware;
+  }
+});
+Object.defineProperty(exports, 'initErrorHandler', {
+  enumerable: true,
+  get: function () {
+    return initErrorHandler;
+  }
+});
+Object.defineProperty(exports, 'initHooksMiddleware', {
+  enumerable: true,
+  get: function () {
+    return initHooksMiddleware;
+  }
+});
+Object.defineProperty(exports, 'listSessions', {
+  enumerable: true,
+  get: function () {
+    return listSessions;
+  }
+});
+Object.defineProperty(exports, 'requestOnlySessionMiddleware', {
+  enumerable: true,
+  get: function () {
+    return requestOnlySessionMiddleware;
+  }
+});
+Object.defineProperty(exports, 'revokeOtherSessions', {
+  enumerable: true,
+  get: function () {
+    return revokeOtherSessions;
+  }
+});
+Object.defineProperty(exports, 'revokeSession', {
+  enumerable: true,
+  get: function () {
+    return revokeSession;
+  }
+});
+Object.defineProperty(exports, 'revokeSessions', {
+  enumerable: true,
+  get: function () {
+    return revokeSessions;
+  }
+});
+Object.defineProperty(exports, 'sensitiveSessionMiddleware', {
+  enumerable: true,
+  get: function () {
+    return sensitiveSessionMiddleware;
+  }
+});
+Object.defineProperty(exports, 'sessionMiddleware', {
+  enumerable: true,
+  get: function () {
+    return sessionMiddleware;
+  }
+});
+Object.defineProperty(exports, 'setDefaultExecutionCtx', {
+  enumerable: true,
+  get: function () {
+    return setDefaultExecutionCtx;
+  }
+});
+Object.defineProperty(exports, 'setRenderer', {
+  enumerable: true,
+  get: function () {
+    return setRenderer;
+  }
+});