ssr-keycloak/dist/client/api-routes.js

SSR compatible Keycloak authentication library for React applications

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createKeycloakAPIRoutes = createKeycloakAPIRoutes;
const auth_handler_1 = require("../server/auth-handler");
const session_1 = require("../server/session");
/**
 * API route handler'ları oluşturur
 */
function createKeycloakAPIRoutes(config) {
    const authHandler = new auth_handler_1.KeycloakAuthHandler(config);
    return {
        // Session bilgilerini döndürür
        async sessionHandler(request) {
            const cookies = Object.fromEntries(request.headers.get('cookie')?.split(';').map(c => {
                const [name, value] = c.trim().split('=');
                return [name, value];
            }) || []);
            const requestContext = {
                cookies,
                headers: {},
                url: request.url,
                method: request.method
            };
            const session = (0, session_1.getSessionFromRequest)(requestContext);
            return Response.json({
                isAuthenticated: (0, session_1.isSessionValid)(session),
                session: session || null,
                user: session?.user || null,
                tokens: session?.tokens || null
            });
        },
        // Login işlemini başlatır
        async loginHandler(request) {
            const url = new URL(request.url);
            const flow = url.searchParams.get('flow') || 'authorization_code';
            const redirectUri = url.searchParams.get('redirectUri');
            const scope = url.searchParams.get('scope');
            const options = {
                flow: flow,
                redirectUri: redirectUri || undefined,
                scope: scope || undefined
            };
            const authUrl = await authHandler.createAuthorizationURL(options.flow, {
                redirectUri: options.redirectUri,
                scope: options.scope
            });
            return Response.json({ authUrl });
        },
        // Logout işlemini gerçekleştirir
        async logoutHandler(request) {
            const url = new URL(request.url);
            const redirectUri = url.searchParams.get('redirectUri');
            const cookies = Object.fromEntries(request.headers.get('cookie')?.split(';').map(c => {
                const [name, value] = c.trim().split('=');
                return [name, value];
            }) || []);
            const requestContext = {
                cookies,
                headers: {},
                url: request.url,
                method: request.method
            };
            const session = (0, session_1.getSessionFromRequest)(requestContext);
            if (session && session.tokens.idToken) {
                const logoutUrl = await authHandler.createLogoutURL(session.tokens.idToken, redirectUri || undefined);
                return Response.json({ logoutUrl });
            }
            return Response.json({ logoutUrl: redirectUri || '/' });
        },
        // Token'ları yeniler
        async refreshHandler(request) {
            const cookies = Object.fromEntries(request.headers.get('cookie')?.split(';').map(c => {
                const [name, value] = c.trim().split('=');
                return [name, value];
            }) || []);
            const requestContext = {
                cookies,
                headers: {},
                url: request.url,
                method: request.method
            };
            const session = (0, session_1.getSessionFromRequest)(requestContext);
            if (!session || !session.tokens.refreshToken) {
                return Response.json({ error: 'No refresh token available' }, { status: 401 });
            }
            try {
                const newTokens = await authHandler.refreshTokens(requestContext, {
                    setCookie: () => { },
                    deleteCookie: () => { },
                    redirect: () => { },
                    json: () => { }
                });
                return Response.json(newTokens);
            }
            catch (error) {
                return Response.json({ error: 'Token refresh failed' }, { status: 401 });
            }
        },
        // Session'ı doğrular
        async validateHandler(request) {
            const cookies = Object.fromEntries(request.headers.get('cookie')?.split(';').map(c => {
                const [name, value] = c.trim().split('=');
                return [name, value];
            }) || []);
            const requestContext = {
                cookies,
                headers: {},
                url: request.url,
                method: request.method
            };
            const isValid = await authHandler.validateSession(requestContext, {
                setCookie: () => { },
                deleteCookie: () => { },
                redirect: () => { },
                json: () => { }
            });
            return Response.json({ isValid });
        },
        // Rol kontrolleri
        async rolesHandler(request) {
            const url = new URL(request.url);
            const role = url.searchParams.get('role');
            const resource = url.searchParams.get('resource');
            const roles = url.searchParams.get('roles')?.split(',');
            const cookies = Object.fromEntries(request.headers.get('cookie')?.split(';').map(c => {
                const [name, value] = c.trim().split('=');
                return [name, value];
            }) || []);
            const requestContext = {
                cookies,
                headers: {},
                url: request.url,
                method: request.method
            };
            const session = (0, session_1.getSessionFromRequest)(requestContext);
            if (!session) {
                return Response.json({ error: 'No session found' }, { status: 401 });
            }
            let result = {};
            if (role) {
                result.hasRole = (0, session_1.hasRoleInSession)(session, role, resource || undefined);
            }
            if (roles) {
                result.hasAnyRole = (0, session_1.hasAnyRoleInSession)(session, roles, resource || undefined);
                result.hasAllRoles = (0, session_1.hasAllRolesInSession)(session, roles, resource || undefined);
            }
            result.userRoles = (0, session_1.getUserRolesFromSession)(session, resource || undefined);
            return Response.json(result);
        }
    };
}