@functionalcms/svelte-components 2.26.1 → 2.28.0

package/dist/auth/authenticationHandle.js

@@ -1,12 +1,13 @@
 import {} from '@sveltejs/kit';
 const authSessionCookieName = `auth_session`;
-const logout = async (cookies, sessionProvider, afterLogoutPath = '/') => {
+const logout = async (cookies, token, provider, 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);
+        await provider.logout(token);
         headers.append('Set-Cookie', `${authSessionCookieName}=; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT;`);
         headers.append('Location', afterLogoutPath);
     }
@@ -53,7 +54,7 @@ export const authenticationHandle = (provider, sessionProvider) => {
         //logout
         if (event.url.pathname === '/auth/logout') {
             // await provider.logout();
-            const headers = await logout(event.cookies, sessionProvider);
+            const headers = await logout(event.cookies, event.locals.token, provider, sessionProvider);
             return new Response('Logging Out...', { status: 303, headers });
         }
         // login

package/dist/auth/machineAuthenticationProvider.d.ts

@@ -3,5 +3,6 @@ export declare const machineAuthenticationProvider: (scope?: string, redirectPat
     getAuthIdentity: (domain: string) => Promise<any>;
     getValidation: (event: any) => Promise<Token>;
     getUser: (token: Token) => Promise<any>;
+    logout: (token: Token) => Promise<void>;
     redirectPath: string;
 };

package/dist/auth/machineAuthenticationProvider.js

@@ -63,6 +63,23 @@ const getUser = async (issuer, token) => {
         });
     }
 };
+const logout = async (issuer, clientId, token) => {
+    const response = await fetch(`${issuer}/protocol/openid-connect/logout`, {
+        method: "POST",
+        body: new URLSearchParams({
+            client_id: clientId,
+            access_token: token.access_token,
+        }),
+        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.');
+    }
+};
 export const machineAuthenticationProvider = (scope = '', redirectPath = '/') => {
     const extendedScope = `openid profile offline_access ${scope}`;
     const redirectUrl = "/auth/validate";
@@ -80,6 +97,9 @@ export const machineAuthenticationProvider = (scope = '', redirectPath = '/') =>
             const user = await getUser(AUTH_KEYCLOAK_ISSUER, token);
             return user;
         },
+        logout: async (token) => {
+            await logout(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, token);
+        },
         redirectPath
     };
 };

package/dist/auth/redisSessionProvider copy.d.ts

@@ -0,0 +1,14 @@
+import type { ISession, Sid } from './types.js';
+declare function clean(): Promise<void>;
+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>;
+export declare const redisSessionProvider: {
+    clean: typeof clean;
+    createSession: typeof createSession;
+    getSession: typeof getSession;
+    deleteSession: typeof deleteSession;
+    updateSession: typeof updateSession;
+};
+export {};

package/dist/auth/redisSessionProvider copy.js

@@ -0,0 +1,45 @@
+import { getSid } from './sessionIdGenerator.js';
+import Redis from "ioredis";
+import { CACHE_SECRET } from '$env/static/private';
+const url = "functional.redis.cache.windows.net:6380,password=cfENm4qUceDQ2lE8tl5LFLjg4IVx3F4mIAzCaA12xtg=,ssl=True,abortConnect=False";
+const redis = new Redis(6380, "functional.redis.cache.windows.net", {
+    password: CACHE_SECRET,
+    tls: true
+});
+async function clean() {
+}
+async function createSession(session, maxAge) {
+    const sid = getSid();
+    const sessionObject = {
+        data: session,
+        invalidAt: Date.now() + maxAge + 3600
+    };
+    await redis.set(sid, JSON.stringify(sessionObject), "EX", maxAge);
+    return sid;
+}
+async function updateSession(sid, session, maxAge) {
+    await redis.del(sid);
+    const sessionObject = {
+        data: session,
+        invalidAt: Date.now() + maxAge + 3600
+    };
+    await redis.set(sid, JSON.stringify(sessionObject), "EX", maxAge);
+}
+async function getSession(sid) {
+    const savedSession = await redis.get(sid);
+    if (savedSession) {
+        const session = JSON.parse(savedSession);
+        return session.data;
+    }
+    return null;
+}
+async function deleteSession(sid) {
+    await redis.del(sid);
+}
+export const redisSessionProvider = {
+    clean: clean,
+    createSession: createSession,
+    getSession: getSession,
+    deleteSession: deleteSession,
+    updateSession: updateSession
+};

package/dist/auth/standardPipeline.d.ts

@@ -0,0 +1,2 @@
+import type { IProvider } from "./types.js";
+export declare const getStandardHandle: (authProvider: IProvider) => import("@sveltejs/kit").Handle;

package/dist/auth/standardPipeline.js

@@ -0,0 +1,7 @@
+import { sequence } from "@sveltejs/kit/hooks";
+import errorHandler from "./errorHandle.js";
+import { tokenRefreshHandle } from "./tokenRefreshHandle.js";
+import authorizationHandle from "./authorizationHandle.js";
+import { authenticationHandle } from "./authenticationHandle.js";
+import { redisSessionProvider } from "./redisSessionProvider.js";
+export const getStandardHandle = (authProvider) => sequence(errorHandler, authenticationHandle(authProvider, redisSessionProvider), tokenRefreshHandle(redisSessionProvider), authorizationHandle(['/.+']));

package/dist/auth/tokenRefreshHandle.d.ts

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

package/dist/auth/tokenRefreshHandle.js

@@ -0,0 +1,48 @@
+import {} from '@sveltejs/kit';
+import { AUTH_KEYCLOAK_ID, AUTH_KEYCLOAK_SECRET, AUTH_KEYCLOAK_ISSUER } from '$env/static/private';
+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, refresh_token) {
+    const response = await fetch(`${AUTH_KEYCLOAK_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) => {
+    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, 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/auth/types.d.ts

@@ -22,6 +22,7 @@ export interface IProvider {
     getAuthIdentity(domain: string): Promise<any>;
     getValidation(event: any): Promise<Token>;
     getUser(token: Token): any;
+    logout(token: Token): Promise<any>;
 }
 export interface ISessionStorage {
     clean(): Promise<void>;

package/dist/auth/userAuthenticationProvider.d.ts

@@ -3,5 +3,6 @@ export declare const userAuthenticationProvider: (scope?: string, redirectPath?:
     getAuthIdentity: (domain: string) => Promise<any>;
     getValidation: (event: any) => Promise<Token>;
     getUser: (token: Token) => Promise<any>;
+    logout: (token: Token) => Promise<void>;
     redirectPath: string;
 };

package/dist/auth/userAuthenticationProvider.js

@@ -76,6 +76,23 @@ const getUser = async (issuer, token) => {
         });
     }
 };
+const logout = async (issuer, clientId, token) => {
+    const response = await fetch(`${issuer}/protocol/openid-connect/logout`, {
+        method: "POST",
+        body: new URLSearchParams({
+            client_id: clientId,
+            access_token: token.access_token,
+        }),
+        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.');
+    }
+};
 export const userAuthenticationProvider = (scope = '', redirectPath = '/') => {
     const extendedScope = `openid profile offline_access ${scope}`;
     const redirectUrl = "/auth/validate";
@@ -93,6 +110,9 @@ export const userAuthenticationProvider = (scope = '', redirectPath = '/') => {
             const user = await getUser(AUTH_KEYCLOAK_ISSUER, token);
             return user;
         },
+        logout: async (token) => {
+            await logout(AUTH_KEYCLOAK_ISSUER, AUTH_KEYCLOAK_ID, token);
+        },
         redirectPath
     };
 };

package/dist/index-server.d.ts

@@ -1,6 +1,8 @@
 export { authenticationHandle } from './auth/authenticationHandle.js';
 export { default as authorizationHandle } from './auth/authorizationHandle.js';
 export { default as errorHandler } from './auth/errorHandle.js';
+export { tokenRefreshHandle } from './auth/tokenRefreshHandle.js';
+export { getStandardHandle } from './auth/standardPipeline.js';
 export { inMemorySessionProvider } from './auth/inMemorySessionProvider.js';
 export { redisSessionProvider } from './auth/redisSessionProvider.js';
 export { machineAuthenticationProvider } from './auth/machineAuthenticationProvider.js';

package/dist/index-server.js

@@ -1,6 +1,8 @@
 export { authenticationHandle } from './auth/authenticationHandle.js';
 export { default as authorizationHandle } from './auth/authorizationHandle.js';
 export { default as errorHandler } from './auth/errorHandle.js';
+export { tokenRefreshHandle } from './auth/tokenRefreshHandle.js';
+export { getStandardHandle } from './auth/standardPipeline.js';
 export { inMemorySessionProvider } from './auth/inMemorySessionProvider.js';
 export { redisSessionProvider } from './auth/redisSessionProvider.js';
 export { machineAuthenticationProvider } from './auth/machineAuthenticationProvider.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@functionalcms/svelte-components",
-	"version": "2.26.1",
+	"version": "2.28.0",
 	"watch": {
 		"build": {
 			"patterns": [