@functionalcms/svelte-components 5.1.7 → 5.2.0

package/dist/components/form/form.d.ts

@@ -73,7 +73,7 @@ export type PhoneInputField = FieldDef & {
     size: "md" | "sm" | "lg";
     placeholder?: string;
 };
-export type Field = InputField | TextareaField | CollectionField | SelectField | FilePickerField | TimePickerField | PhoneInputField;
+export type Field = InputField | TextareaField | CollectionField | SelectField | FilePickerField | TimePickerField | PhoneInputField | HiddenField;
 export declare enum SubmitResult {
     Success = "success",
     Error = "error"

package/dist/index-server.d.ts

@@ -1,12 +1,12 @@
-export { authenticationHandle } from './server-side/auth/authenticationHandle.js';
 export { default as authorizationHandle } from './server-side/auth/authorizationHandle.js';
 export { default as errorHandler } from './server-side/auth/errorHandle.js';
-export { redisSessionProvider } from './server-side/auth/redisSessionProvider.js';
+export { authenticationHandle } from './server-side/auth/authentication.js';
 export { machineAuthenticationProvider } from './server-side/auth/machineAuthenticationProvider.js';
 export { userAuthenticationProvider } from './server-side/auth/userAuthenticationProvider.js';
+export { hookSequence } from './server-side/functionalSequence.js';
+export { sessionHandler } from './server-side/handlers/sessionHandler.js';
 export { getCommunicationService, getDataService, getTemplateService, getWebsiteService, getAuthService, getFileService, } from './server-side/getServices.js';
 export type { RedirectResponse } from './server-side/auth/RedirectResponse.js';
-export { createMachineTokenApprovedLocals } from './server-side/auth/getMachineAccessToken.js';
 export { isHuman } from './components/form/AntiBot.js';
 export { paraglideHandler } from './server-side/handlers/paraglideHandler.js';
 export { redirectPipelineHandler } from './server-side/handlers/redirectPipelineHandler.js';

package/dist/index-server.js

@@ -1,11 +1,11 @@
-export { authenticationHandle } from './server-side/auth/authenticationHandle.js';
 export { default as authorizationHandle } from './server-side/auth/authorizationHandle.js';
 export { default as errorHandler } from './server-side/auth/errorHandle.js';
-export { redisSessionProvider } from './server-side/auth/redisSessionProvider.js';
+export { authenticationHandle } from './server-side/auth/authentication.js';
 export { machineAuthenticationProvider } from './server-side/auth/machineAuthenticationProvider.js';
 export { userAuthenticationProvider } from './server-side/auth/userAuthenticationProvider.js';
+export { hookSequence } from './server-side/functionalSequence.js';
+export { sessionHandler } from './server-side/handlers/sessionHandler.js';
 export { getCommunicationService, getDataService, getTemplateService, getWebsiteService, getAuthService, getFileService, } from './server-side/getServices.js';
-export { createMachineTokenApprovedLocals } from './server-side/auth/getMachineAccessToken.js';
 export { isHuman } from './components/form/AntiBot.js';
 export { paraglideHandler } from './server-side/handlers/paraglideHandler.js';
 export { redirectPipelineHandler } from './server-side/handlers/redirectPipelineHandler.js';

package/dist/server-side/auth/authentication.d.ts

@@ -0,0 +1,17 @@
+import type { Handle } from "@sveltejs/kit";
+export type CallbackResponse = {
+    access_token: string;
+    id_token?: string;
+    refresh_token?: string;
+    redirectionUrl: string;
+};
+export type SigninResponse = {
+    state: string;
+    codeVerifier: string;
+    authorisationUrl: string;
+};
+export type AuthenticationProvider = {
+    handleLogin(callbackUrl: URL): Promise<SigninResponse>;
+    handleCallback: (state: string, codeVerifier: string, eventUrl: URL) => Promise<CallbackResponse>;
+};
+export declare const authenticationHandle: (secret: string, provider: AuthenticationProvider) => Handle;

package/dist/server-side/auth/authentication.js

@@ -0,0 +1,72 @@
+import { deleteCookie, loadCookie, saveCookie } from "../cookies";
+const pkceCookieName = "functionalcms_pkce";
+const stateCookieName = "functionalcms_state";
+const accessTokenCookie = "functionalcms_access_token";
+const idTokenCookie = "functionalcms_id_token";
+const refreshTokenCookie = "functionalcms_refresh_token";
+export const authenticationHandle = (secret, provider) => {
+    return async ({ event, resolve }) => {
+        try {
+            if (event.url.pathname === '/auth/callback') {
+                const headers = await handleCallback(event, secret, provider);
+                return new Response(null, { status: 302, headers });
+            }
+            else if (event.url.pathname === '/auth/login') {
+                const headers = await handleLogin(event, provider, secret);
+                return new Response(null, { status: 302, headers });
+            }
+            else if (event.url.pathname === '/auth/logout') {
+                handleLogout(event);
+                // } else {
+                //     const hasUser = event.locals.user;
+                //     const accessToken = await loadCookie(event.cookies, secret, accessTokenCookie);
+                //     const idToken = await loadCookie(event.cookies, secret, idTokenCookie);
+                //     console.log(`accessToken: ${accessToken}, idToken: ${idToken}, hasUser: ${hasUser}`);
+                //     if (!hasUser && accessToken != "") {
+                //         await loginUserWithToken(event, accessToken, idToken, provider);
+                //     }
+            }
+        }
+        catch (error) {
+            console.error("Authentication error:", error);
+        }
+        return resolve(event);
+    };
+};
+function handleLogout(event) {
+    event.cookies.delete(accessTokenCookie, { path: "/" });
+    event.cookies.delete(idTokenCookie, { path: "/" });
+    event.cookies.delete(refreshTokenCookie, { path: "/" });
+    event.locals.user = null;
+    event.locals.session = null;
+}
+async function handleLogin(event, provider, secret) {
+    const callbackUrl = new URL(`${event.url.origin}/auth/callback`);
+    const response = await provider.handleLogin(callbackUrl);
+    const headers = new Headers();
+    headers.set('Location', response.authorisationUrl);
+    await saveCookie(headers, secret, pkceCookieName, response.codeVerifier);
+    await saveCookie(headers, secret, stateCookieName, response.state);
+    return headers;
+}
+async function handleCallback(event, secret, provider) {
+    const expectedState = await loadCookie(event.cookies, secret, stateCookieName);
+    const codeVerifier = await loadCookie(event.cookies, secret, pkceCookieName);
+    const response = await provider.handleCallback(expectedState, codeVerifier, event.url);
+    const headers = new Headers();
+    headers.set('Location', event.url.origin);
+    await saveCookie(headers, secret, accessTokenCookie, response.access_token);
+    if (response.id_token) {
+        await saveCookie(headers, secret, idTokenCookie, response.id_token);
+    }
+    if (response.refresh_token) {
+        await saveCookie(headers, secret, refreshTokenCookie, response.refresh_token);
+    }
+    await deleteCookie(event.cookies, headers, pkceCookieName);
+    await deleteCookie(event.cookies, headers, stateCookieName);
+    return headers;
+}
+// async function loginUserWithToken(event: any, accessToken: string, idToken: string, provider: AuthenticationProvider) {
+//     const user = await provider.retrieveUser(accessToken);
+//     event.locals.user = user;
+// }

package/dist/server-side/auth/authorizationHandle.js

@@ -4,8 +4,8 @@ const authorizationHandle = () => {
         if (path.startsWith('/auth/') === false) {
             const route = event.route;
             if (route.id.includes('/(protect)')) {
-                const session = event?.locals?.session;
-                if (!session) {
+                const user = event?.locals?.user;
+                if (!user) {
                     const cookieHeader = `retrunToAddress=${event.url.toString()}; HttpOnly; Secure; SameSite=Lax; Max-Age=3600; Path=/`;
                     return new Response('Login user', {
                         status: 303,

package/dist/server-side/auth/machineAuthenticationProvider.d.ts

@@ -1,7 +1,2 @@
-import type { Token } from './types.js';
-export declare const machineAuthenticationProvider: (AUTH_KEYCLOAK_ID: string, AUTH_KEYCLOAK_SECRET: string, AUTH_KEYCLOAK_ISSUER: string, scope?: string, redirectPath?: string) => {
-    getAuthIdentity: (domain: string) => Promise<any>;
-    getValidation: (event: any) => Promise<Token>;
-    getUser: (token: Token) => Promise<any>;
-    redirectPath: string;
-};
+import type { AuthenticationProvider } from "./authentication";
+export declare const machineAuthenticationProvider: (serverUrl: string, clientId: string, clientSecret: string, redirectUrl: string) => AuthenticationProvider;

package/dist/server-side/auth/machineAuthenticationProvider.js

@@ -1,69 +1,33 @@
-const getKeycloakIdentity = async (issuer, client_id, scope, redirectUrl) => {
-    const headers = new Headers();
-    headers.append('Location', '/auth/validate');
-    return headers;
-};
-const getKeycloakValidation = async (issuer, client_id, client_secret, scope, event) => {
-    const response = await fetch(`${issuer}/protocol/openid-connect/token`, {
-        method: "POST",
-        body: new URLSearchParams({
-            grant_type: "client_credentials",
-            client_id: client_id,
-            client_secret: client_secret,
-            scope,
-        }),
-        headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            Accept: "application/json"
-        }
-    });
-    if (!response.ok) {
-        console.log('Response was NOT okay');
-        throw new Error('Token not validated.');
-    }
-    const token = await response.json();
-    return token;
-};
-const getUser = async (issuer, token) => {
-    try {
-        const accessToken = token.access_token;
-        const response = await fetch(`${issuer}/protocol/openid-connect/userinfo`, {
+export const machineAuthenticationProvider = (serverUrl, clientId, clientSecret, redirectUrl) => {
+    const handleLogin = (callbackUrl) => {
+        const response = {
+            state: "",
+            codeVerifier: "",
+            authorisationUrl: callbackUrl.toString(),
+        };
+        return Promise.resolve(response);
+    };
+    const handleCallback = async (state, codeVerifier, eventUrl) => {
+        const tokenRes = await fetch(`${serverUrl}/api/login/oauth/access_token`, {
             method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-                Accept: "application/json",
-                Authorization: `Bearer ${accessToken}`
-            }
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "client_credentials",
+                client_id: clientId,
+                client_secret: clientSecret,
+                scope: "profile openid  email offline_access"
+            })
         });
-        if (!response.ok) {
-            throw new Error('Failed to fetch user information.');
-        }
-        const data = await response.json();
-        return data;
-    }
-    catch (error) {
-        return new Response(null, {
-            status: 400
-        });
-    }
-};
-export const machineAuthenticationProvider = (AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, AUTH_KEYCLOAK_ISSUER, scope = '', redirectPath = '/') => {
-    const extendedScope = `openid profile offline_access ${scope}`;
-    const redirectUrl = "/auth/validate";
+        const tokens = await tokenRes.json();
+        return {
+            access_token: tokens.access_token,
+            id_token: tokens.id_token,
+            refresh_token: tokens.refresh_token,
+            redirectionUrl: redirectUrl,
+        };
+    };
     return {
-        getAuthIdentity: async (domain) => {
-            const provider = await getKeycloakIdentity(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, extendedScope, `${domain}${redirectUrl}`);
-            return provider;
-        },
-        getValidation: async (event) => {
-            const fullRedirectUrl = `${event.url.origin}${redirectUrl}`;
-            const token = await getKeycloakValidation(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, extendedScope, event);
-            return token;
-        },
-        getUser: async (token) => {
-            const user = await getUser(AUTH_KEYCLOAK_ISSUER, token);
-            return user;
-        },
-        redirectPath
+        handleLogin,
+        handleCallback,
     };
 };

package/dist/server-side/auth/userAuthenticationProvider.d.ts

@@ -1,7 +1,2 @@
-import type { Token } from './types.js';
-export declare const userAuthenticationProvider: (AUTH_KEYCLOAK_ID: string, AUTH_KEYCLOAK_ISSUER: string, scope?: string, redirectPath?: string) => {
-    getAuthIdentity: (domain: string) => Promise<any>;
-    getValidation: (event: any) => Promise<Token>;
-    getUser: (token: Token) => Promise<any>;
-    redirectPath: string;
-};
+import type { AuthenticationProvider } from "./authentication";
+export declare const userAuthenticationProvider: (serverUrl: string, clientId: string) => AuthenticationProvider;

package/dist/server-side/auth/userAuthenticationProvider.js

@@ -1,97 +1,45 @@
 import * as o from "oauth4webapi";
-const authStateCookieName = 'auth_state';
-const stateIdGenerator = () => crypto.randomUUID();
-const getKeycloakIdentity = async (issuer, client_id, scope, redirectUrl) => {
-    const state = stateIdGenerator();
-    const cookieHeader = `${authStateCookieName}=${state}; HttpOnly; Secure; SameSite=Lax; Max-Age=3600; Path=/`;
-    const code_challenge = await o.calculatePKCECodeChallenge(state);
-    const authorizationUrlSearchParams = new URLSearchParams({
-        client_id: client_id,
-        redirect_uri: redirectUrl,
-        response_type: 'code',
-        state,
-        scope,
-        code_challenge
-    });
-    const authorizationUrl = `${issuer}/protocol/openid-connect/auth?${authorizationUrlSearchParams}`;
-    const headers = new Headers();
-    headers.append('Set-Cookie', cookieHeader);
-    headers.append('Location', authorizationUrl);
-    return headers;
-};
-const getKeycloakValidation = async (issuer, client_id, scope, event, redirectUrl) => {
-    const storedState = event.cookies.get(authStateCookieName);
-    const state = event.url.searchParams.get("state");
-    if (!storedState || !state || storedState !== state) {
-        throw new Error('State not valid');
-    }
-    const code = event.url.searchParams.get("code");
-    if (!code) {
-        throw new Error('Challenge code not valid');
-    }
-    const code_challenge = await o.calculatePKCECodeChallenge(state);
-    const response = await fetch(`${issuer}/protocol/openid-connect/token`, {
-        method: "POST",
-        body: new URLSearchParams({
-            grant_type: "authorization_code",
-            client_id: client_id,
-            redirect_uri: redirectUrl,
-            code_verifier: code_challenge,
-            code,
-            scope,
-        }),
-        headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            Accept: "application/json"
-        }
-    });
-    if (!response.ok) {
-        console.log('Response was NOT okay');
-        throw new Error('Token not validated.');
-    }
-    const token = await response.json();
-    return token;
-};
-const getUser = async (issuer, token) => {
-    try {
-        const accessToken = token.access_token;
-        const response = await fetch(`${issuer}/protocol/openid-connect/userinfo`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded",
-                Accept: "application/json",
-                Authorization: `Bearer ${accessToken}`
-            }
-        });
-        if (!response.ok) {
-            throw new Error('Failed to fetch user information.');
-        }
-        const data = await response.json();
-        return data;
-    }
-    catch (error) {
-        return new Response(null, {
-            status: 400
-        });
-    }
-};
-export const userAuthenticationProvider = (AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_ISSUER, scope = '', redirectPath = '/') => {
-    const extendedScope = `openid profile offline_access ${scope}`;
-    const redirectUrl = "/auth/validate";
+function generateRandomState() {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export const userAuthenticationProvider = (serverUrl, clientId) => {
+    const client = {
+        client_id: clientId,
+        token_endpoint_auth_method: "none"
+    };
+    const issuer = new URL(serverUrl);
+    const handleLogin = async (callbackUrl) => {
+        const code_verifier = o.generateRandomCodeVerifier();
+        const code_challenge = await o.calculatePKCECodeChallenge(code_verifier);
+        const state = generateRandomState();
+        const authUrl = new URL(serverUrl + '/login/oauth/authorize');
+        authUrl.searchParams.set('client_id', clientId);
+        authUrl.searchParams.set('redirect_uri', callbackUrl.toString());
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('state', state);
+        authUrl.searchParams.set('code_challenge', code_challenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        return { state, codeVerifier: code_verifier, authorisationUrl: authUrl.toString() };
+    };
+    const handleCallback = async (state, codeVerifier, callbackUrl) => {
+        const discovery = await o.discoveryRequest(issuer);
+        const metadata = await o.processDiscoveryResponse(issuer, discovery);
+        const callbackParameters = o.validateAuthResponse(metadata, client, callbackUrl, state);
+        // Exchange code for tokens
+        const tokenResponse = await o.authorizationCodeGrantRequest(metadata, client, o.None(), callbackParameters, callbackUrl.toString(), codeVerifier);
+        // Parse tokens
+        const tokens = await o.processAuthorizationCodeResponse(metadata, client, tokenResponse);
+        return {
+            access_token: tokens.access_token,
+            id_token: tokens.id_token,
+            refresh_token: tokens.refresh_token,
+            redirectionUrl: callbackUrl.toString(),
+        };
+    };
     return {
-        getAuthIdentity: async (domain) => {
-            const provider = await getKeycloakIdentity(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, extendedScope, `${domain}${redirectUrl}`);
-            return provider;
-        },
-        getValidation: async (event) => {
-            const fullRedirectUrl = `${event.url.origin}${redirectUrl}`;
-            const token = await getKeycloakValidation(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, extendedScope, event, fullRedirectUrl);
-            return token;
-        },
-        getUser: async (token) => {
-            const user = await getUser(AUTH_KEYCLOAK_ISSUER, token);
-            return user;
-        },
-        redirectPath
+        handleLogin,
+        handleCallback,
     };
 };

package/dist/server-side/cookies.d.ts

@@ -0,0 +1,3 @@
+export declare const saveCookie: (headers: Headers, secret: string, name: string, value: string) => Promise<void>;
+export declare const loadCookie: (cookies: any, secret: string, name: string) => Promise<string>;
+export declare const deleteCookie: (cookies: any, headers: Headers, cookieName: string) => void;

package/dist/server-side/cookies.js

@@ -0,0 +1,22 @@
+import { decrypt, encrypt } from "./crypto";
+export const saveCookie = async (headers, secret, name, value) => {
+    const encryptedValue = await encrypt(secret, value);
+    headers.append('Set-Cookie', `${name}=${encryptedValue}; HttpOnly; SameSite=None; Secure; Max-Age=3600; Path=/`);
+};
+export const loadCookie = async (cookies, secret, name) => {
+    const encryptedValue = cookies.get(name);
+    if (encryptedValue) {
+        return await decrypt(secret, encryptedValue);
+    }
+    else {
+        return "";
+    }
+};
+export const deleteCookie = (cookies, headers, cookieName) => {
+    cookies.delete(cookieName, { path: "/" });
+    cookies.set(cookieName, '', {
+        path: '/',
+        maxAge: 0
+    });
+    headers.append('Set-Cookie', `${cookieName}=empty; HttpOnly; SameSite=None; Secure; Max-Age=0; Path=/`);
+};

package/dist/server-side/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(secret: string, value: string): Promise<string>;
+export declare function decrypt(secret: string, value: string): Promise<string>;

package/dist/server-side/crypto.js

@@ -0,0 +1,20 @@
+// src/lib/crypto.ts
+const keyPromise = (secret) => crypto.subtle.importKey("raw", Uint8Array.from(atob(secret), c => c.charCodeAt(0)), { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+export async function encrypt(secret, value) {
+    const key = await keyPromise(secret);
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const encoded = new TextEncoder().encode(value);
+    const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return btoa(String.fromCharCode(...combined));
+}
+export async function decrypt(secret, value) {
+    const key = await keyPromise(secret);
+    const data = Uint8Array.from(atob(value), c => c.charCodeAt(0));
+    const iv = data.slice(0, 12);
+    const ciphertext = data.slice(12);
+    const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+    return new TextDecoder().decode(plaintext);
+}

package/dist/server-side/functionalSequence.d.ts

@@ -0,0 +1,2 @@
+import type { Handle } from "@sveltejs/kit";
+export declare const hookSequence: (secret: string, paraglideMiddleware: any, getTextDirection: any, customHooks: Handle[]) => Handle;

package/dist/server-side/functionalSequence.js

@@ -0,0 +1,8 @@
+import { sequence } from "@sveltejs/kit/hooks";
+import errorHandler from "./auth/errorHandle";
+import { paraglideHandler } from "./handlers/paraglideHandler";
+import sessionHandler from "./handlers/sessionHandler";
+import authorizationHandle from "./auth/authorizationHandle";
+export const hookSequence = (secret, paraglideMiddleware, getTextDirection, customHooks) => {
+    return sequence(sessionHandler(secret), errorHandler, paraglideHandler(paraglideMiddleware, getTextDirection), authorizationHandle(), ...customHooks);
+};

package/dist/server-side/handlers/sessionHandler.d.ts

@@ -0,0 +1,3 @@
+import { type Handle } from '@sveltejs/kit';
+export declare const sessionHandler: (secret: string) => Handle;
+export default sessionHandler;

package/dist/server-side/handlers/sessionHandler.js

@@ -0,0 +1,15 @@
+import {} from '@sveltejs/kit';
+import { loadCookie, saveCookie } from '../cookies';
+export const sessionHandler = (secret) => {
+    return async ({ event, resolve }) => {
+        const session = event?.locals?.session;
+        if (!session) {
+            let session = await loadCookie(event.cookies, secret, "session");
+            event.locals.session = session;
+        }
+        const result = await resolve(event);
+        await saveCookie(result.headers, secret, "session", event.locals.session);
+        return result;
+    };
+};
+export default sessionHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@functionalcms/svelte-components",
-	"version": "5.1.7",
+	"version": "5.2.0",
 	"license": "MIT",
 	"watch": {
 		"build": {

package/dist/server-side/auth/authenticationHandle.d.ts

@@ -1,3 +0,0 @@
-import { type Handle } from '@sveltejs/kit';
-import type { IProvider, ISessionStorage } from './types.js';
-export declare const authenticationHandle: (provider: IProvider, sessionProvider: ISessionStorage) => Handle;

package/dist/server-side/auth/authenticationHandle.js

@@ -1,67 +0,0 @@
-import {} from '@sveltejs/kit';
-const authSessionCookieName = `auth_session`;
-const logout = async (cookies, sessionProvider, afterLogoutPath = '/') => {
-    const headers = new Headers();
-    const state = cookies.get(authSessionCookieName);
-    if (state) {
-        cookies.delete('auth_session', { path: '/' });
-        const sid = cookies.get('auth_session');
-        await sessionProvider.deleteSession(sid);
-        headers.append('Set-Cookie', `${authSessionCookieName}=; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT;`);
-        headers.append('Location', afterLogoutPath);
-    }
-    else {
-        headers.append('Location', '/');
-    }
-    return headers;
-};
-const createUserSession = async (provider, event, sessionProvider) => {
-    const token = await provider.getValidation(event);
-    const session = await provider.getUser(token);
-    const headers = new Headers();
-    if (session !== undefined) {
-        session.userId = session.sub;
-        event.locals.session = session;
-        event.locals.accessToken = token.access_token;
-        const sessionId = await sessionProvider.createSession({ session, token }, token.expires_in);
-        const retrunToAddress = event.cookies.get("retrunToAddress");
-        headers.append('Location', retrunToAddress ? retrunToAddress : provider.redirectPath);
-        headers.append('Set-Cookie', `${authSessionCookieName}=${sessionId}; HttpOnly; Secure; SameSite=Lax; Max-Age=${token.expires_in + 120}; Path=/`);
-        headers.append('Set-Cookie', `retrunToAddress=; HttpOnly; Secure; SameSite=Lax; Max-Age=${token.expires_in + 120}; Path=/`);
-    }
-    else {
-        headers.append('Location', '/');
-    }
-    return headers;
-};
-const loadUserFromSession = async (cookies, locals, sessionProvider) => {
-    const sid = cookies.get(authSessionCookieName);
-    const session = await sessionProvider.getSession(sid);
-    if (session) {
-        locals.session = session.session;
-        locals.token = session.token;
-    }
-    else {
-        locals.username = "";
-    }
-};
-export const authenticationHandle = (provider, sessionProvider) => {
-    return async ({ event, resolve }) => {
-        if (event.url.pathname.startsWith('/')) {
-            await loadUserFromSession(event.cookies, event.locals, sessionProvider);
-        }
-        if (event.url.pathname === '/auth/logout') {
-            const headers = await logout(event.cookies, sessionProvider);
-            return new Response('Logging Out...', { status: 303, headers });
-        }
-        else if (event.url.pathname === '/auth/login') {
-            const authProvider = await provider.getAuthIdentity(event.url.origin);
-            return new Response('Redirect', { status: 302, headers: authProvider });
-        }
-        else if (event.url.pathname === "/auth/validate") {
-            const validationResponse = await createUserSession(provider, event, sessionProvider);
-            return new Response('Redirect', { status: 302, headers: validationResponse });
-        }
-        return await resolve(event);
-    };
-};

package/dist/server-side/auth/getMachineAccessToken.d.ts

@@ -1,3 +0,0 @@
-export declare const createMachineTokenApprovedLocals: (AUTH_KEYCLOAK_ID: string, AUTH_KEYCLOAK_SECRET: string, AUTH_KEYCLOAK_ISSUER: string, scope?: string) => Promise<{
-    token: any;
-}>;

package/dist/server-side/auth/getMachineAccessToken.js

@@ -1,25 +0,0 @@
-export const createMachineTokenApprovedLocals = async (AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, AUTH_KEYCLOAK_ISSUER, scope = '') => {
-    const url = `${AUTH_KEYCLOAK_ISSUER}/protocol/openid-connect/token`;
-    const body = new URLSearchParams({
-        grant_type: "client_credentials",
-        client_id: AUTH_KEYCLOAK_ID,
-        client_secret: AUTH_KEYCLOAK_SECRET,
-        scope: `openid profile offline_access ${scope}`,
-    });
-    const response = await fetch(url, {
-        method: "POST",
-        body: body,
-        headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            Accept: "*/*"
-        }
-    });
-    if (!response.ok) {
-        console.log('Response was NOT okay');
-        throw new Error('Token not validated.');
-    }
-    const token = await response.json();
-    return {
-        token: token,
-    };
-};

package/dist/server-side/auth/redisSessionProvider.d.ts

@@ -1,14 +0,0 @@
-import type { ISession, Sid } from './types.js';
-declare function createSession(session: ISession, maxAge: number): Promise<string>;
-declare function updateSession(sid: string, session: ISession, maxAge: number): Promise<void>;
-declare function getSession(sid: Sid): Promise<any>;
-declare function deleteSession(sid: string): Promise<void>;
-declare function clean(): Promise<void>;
-export declare const redisSessionProvider: {
-    clean: typeof clean;
-    createSession: typeof createSession;
-    getSession: typeof getSession;
-    deleteSession: typeof deleteSession;
-    updateSession: typeof updateSession;
-};
-export {};

package/dist/server-side/auth/redisSessionProvider.js

@@ -1,38 +0,0 @@
-import { getSid } from './sessionIdGenerator.js';
-const sessionStore = new Map();
-async function createSession(session, maxAge) {
-    const sid = getSid();
-    const sessionObject = {
-        data: session,
-        invalidAt: Date.now() + maxAge + 3600
-    };
-    sessionStore.set(sid, sessionObject);
-    return sid;
-}
-async function updateSession(sid, session, maxAge) {
-    sessionStore.delete(sid);
-    const sessionObject = {
-        data: session,
-        invalidAt: Date.now() + maxAge + 3600
-    };
-    sessionStore.set(sid, sessionObject);
-}
-async function getSession(sid) {
-    const savedSession = sessionStore.get(sid);
-    if (savedSession) {
-        return savedSession.data;
-    }
-    return null;
-}
-async function deleteSession(sid) {
-    sessionStore.delete(sid);
-}
-async function clean() {
-}
-export const redisSessionProvider = {
-    clean: clean,
-    createSession: createSession,
-    getSession: getSession,
-    deleteSession: deleteSession,
-    updateSession: updateSession
-};

package/dist/server-side/auth/sessionIdGenerator.d.ts

@@ -1,2 +0,0 @@
-import type { Sid } from "./types.js";
-export declare function getSid(): Sid;

package/dist/server-side/auth/sessionIdGenerator.js

@@ -1,3 +0,0 @@
-export function getSid() {
-    return crypto.randomUUID();
-}

package/dist/server-side/auth/tokenRefresh.d.ts

@@ -1,3 +0,0 @@
-import { type Handle } from '@sveltejs/kit';
-import type { ISessionStorage } from './types.js';
-export declare const tokenRefreshHandle: (sessionProvider: ISessionStorage, AUTH_KEYCLOAK_ID: string, AUTH_KEYCLOAK_SECRET: string, AUTH_KEYCLOAK_ISSUER: string) => Handle;

package/dist/server-side/auth/tokenRefresh.js

@@ -1,47 +0,0 @@
-import {} from '@sveltejs/kit';
-const authSessionCookieName = `auth_session`;
-function isTokenExpired(token) {
-    const base64Url = token.split(".")[1];
-    const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-    const jsonPayload = decodeURIComponent(atob(base64)
-        .split("")
-        .map(function (c) {
-        return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
-    })
-        .join(""));
-    const { exp } = JSON.parse(jsonPayload);
-    const expired = Date.now() >= exp * 1000;
-    return expired;
-}
-async function refreshToken(clientId, clientSecret, issuer, refresh_token) {
-    const response = await fetch(`${issuer}/protocol/openid-connect/token`, {
-        method: "POST",
-        body: new URLSearchParams({
-            grant_type: "refresh_token",
-            client_id: clientId,
-            client_secret: clientSecret,
-            refresh_token: refresh_token,
-        }),
-        headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            Accept: "application/json"
-        }
-    });
-    const newToken = await response.json();
-    return newToken;
-}
-export const tokenRefreshHandle = (sessionProvider, AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, AUTH_KEYCLOAK_ISSUER) => {
-    return async ({ event, resolve }) => {
-        const locals = event.locals;
-        if (locals?.token?.refresh_token) {
-            const isExpired = isTokenExpired(locals.token.access_token);
-            if (isExpired) {
-                const newToken = await refreshToken(AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, AUTH_KEYCLOAK_ISSUER, locals.token.refresh_token);
-                locals.token = newToken;
-                const sid = event.cookies.get(authSessionCookieName);
-                sessionProvider.updateSession(sid, locals, newToken.expires_in);
-            }
-        }
-        return await resolve(event);
-    };
-};

package/dist/server-side/auth/types.d.ts

@@ -1,45 +0,0 @@
-export declare class Token {
-    access_token: string;
-    expires_in: number;
-    id_token?: string;
-    refresh_expires_in?: number;
-    refresh_token?: string;
-    scope?: string;
-    session_state?: string;
-    token_type?: string;
-}
-export interface Session {
-    client_id: string;
-    email_verified: string;
-    preferred_username: string;
-    sub: string;
-    userId: string;
-}
-export interface Locals {
-    session: Session | undefined;
-    auth_token: string;
-}
-export type ISession = {
-    session: Session;
-    token: Token;
-};
-export type SessionInfoCache = {
-    data: ISession;
-    invalidAt: number;
-};
-export type Sid = string;
-export interface IProvider {
-    redirectPath: string;
-    getAuthIdentity(domain: string): Promise<any>;
-    getValidation(event: any): Promise<Token>;
-    getUser(token: Token): any;
-}
-export interface ISessionStorage {
-    clean(): Promise<void>;
-    createSession(session: ISession, maxAge: number): Promise<Sid>;
-    getSession(sid: Sid): Promise<ISession | undefined>;
-    deleteSession(sid: Sid): Promise<void>;
-    updateSession(sid: Sid, session: ISession, maxAge: number): Promise<void>;
-}
-export interface Cookies {
-}

package/dist/server-side/auth/types.js

@@ -1,6 +0,0 @@
-export class Token {
-    constructor() {
-        this.access_token = "";
-        this.expires_in = 0;
-    }
-}