@functionalcms/svelte-components 5.14.0 → 5.15.1

package/dist/index-server.d.ts

@@ -1,7 +1,7 @@
 export { default as authorizationHandle } from './server-side/auth/authorizationHandle.js';
 export { default as errorHandler } from './server-side/auth/errorHandle.js';
-export { authenticationHandle } from './server-side/auth/user_authentication.js';
-export { machineAuthenticationHandle } from './server-side/auth/machine_authentication.js';
+export { userAuthenticationHandle } from './server-side/auth/userAuthenticationHandle.js';
+export { machineAuthenticationHandle } from './server-side/auth/machineAuthenticationHandle.js';
 export { userAuthenticationProvider } from './server-side/auth/userAuthenticationProvider.js';
 export { hookSequence } from './server-side/functionalSequence.js';
 export { sessionStorageHandler } from './server-side/handlers/sessionStorageHandler.js';

package/dist/index-server.js

@@ -1,7 +1,7 @@
 export { default as authorizationHandle } from './server-side/auth/authorizationHandle.js';
 export { default as errorHandler } from './server-side/auth/errorHandle.js';
-export { authenticationHandle } from './server-side/auth/user_authentication.js';
-export { machineAuthenticationHandle } from './server-side/auth/machine_authentication.js';
+export { userAuthenticationHandle } from './server-side/auth/userAuthenticationHandle.js';
+export { machineAuthenticationHandle } from './server-side/auth/machineAuthenticationHandle.js';
 export { userAuthenticationProvider } from './server-side/auth/userAuthenticationProvider.js';
 export { hookSequence } from './server-side/functionalSequence.js';
 export { sessionStorageHandler } from './server-side/handlers/sessionStorageHandler.js';

package/dist/server-side/auth/{user_authentication.d.ts → userAuthenticationHandle.d.ts}

@@ -1,4 +1,5 @@
 import type { Handle } from "@sveltejs/kit";
+import { Redis } from "@upstash/redis";
 export type CallbackResponse = {
     access_token: string;
     id_token?: string;
@@ -13,4 +14,4 @@ export type AuthenticationProvider = {
     handleLogin(callbackUrl: URL): Promise<SigninResponse>;
     handleCallback: (state: string, codeVerifier: string, eventUrl: URL) => Promise<CallbackResponse>;
 };
-export declare const authenticationHandle: (secret: string, serverUrl: string, clientId: string) => Handle;
+export declare const userAuthenticationHandle: (secret: string, serverUrl: string, clientId: string, redis: Redis) => Handle;

package/dist/server-side/auth/{user_authentication.js → userAuthenticationHandle.js}

@@ -1,17 +1,16 @@
 import { deleteCookie, loadCookie, saveCookie } from "../cookies";
 import { userAuthenticationProvider } from "./userAuthenticationProvider";
-import { parse } from "svelte/compiler";
+import { Redis } from "@upstash/redis";
+import { parseJwtToken } from "../tokenToUserParser";
 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, serverUrl, clientId) => {
+const sessionCookieName = "functionalcms_sessionId";
+export const userAuthenticationHandle = (secret, serverUrl, clientId, redis) => {
     const provider = userAuthenticationProvider(serverUrl, clientId);
     return async ({ event, resolve }) => {
         try {
             if (event.url.pathname === '/auth/callback') {
-                const headers = await handleCallback(event, secret, provider);
+                const headers = await handleCallback(event, secret, provider, redis);
                 return new Response(null, { status: 302, headers });
             }
             else if (event.url.pathname === '/auth/login') {
@@ -29,22 +28,12 @@ export const authenticationHandle = (secret, serverUrl, clientId) => {
     };
 };
 function handleLogout(event) {
-    event.cookies.delete(accessTokenCookie, { path: "/" });
-    event.cookies.delete(idTokenCookie, { path: "/" });
-    event.cookies.delete(refreshTokenCookie, { path: "/" });
+    event.cookies.delete(sessionCookieName, { path: "/" });
+    // event.cookies.delete(idTokenCookie, { path: "/" });
+    // event.cookies.delete(refreshTokenCookie, { path: "/" });
     event.locals.user = null;
     event.locals.session = {};
 }
-function parseJwt(token) {
-    const base64 = token.split('.')[1]
-        .replace(/-/g, '+')
-        .replace(/_/g, '/');
-    const json = decodeURIComponent(atob(base64)
-        .split('')
-        .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
-        .join(''));
-    return JSON.parse(json);
-}
 async function handleLogin(event, provider, secret) {
     const callbackUrl = new URL(`${event.url.origin}/auth/callback`);
     const response = await provider.handleLogin(callbackUrl);
@@ -54,20 +43,16 @@ async function handleLogin(event, provider, secret) {
     await saveCookie(headers, secret, stateCookieName, response.state);
     return headers;
 }
-async function handleCallback(event, secret, provider) {
+async function handleCallback(event, secret, provider, redis) {
     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);
-    const accessToken = parseJwt(response.access_token);
-    await saveCookie(headers, secret, accessTokenCookie, response.access_token, accessToken.exp - Math.floor(Date.now() / 1000));
-    if (response.id_token) {
-        await saveCookie(headers, secret, idTokenCookie, response.id_token);
-    }
-    if (response.refresh_token) {
-        await saveCookie(headers, secret, refreshTokenCookie, response.refresh_token);
-    }
+    const sessionId = crypto.randomUUID();
+    const accessToken = parseJwtToken(response.access_token);
+    await saveCookie(headers, secret, sessionCookieName, sessionId, accessToken.exp - Math.floor(Date.now() / 1000));
+    redis.set(sessionId, JSON.stringify(response.access_token), { ex: accessToken.exp - Math.floor(Date.now() / 1000) });
     await deleteCookie(event.cookies, headers, pkceCookieName);
     await deleteCookie(event.cookies, headers, stateCookieName);
     return headers;

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

@@ -1,2 +1,2 @@
-import type { AuthenticationProvider } from "./user_authentication";
+import type { AuthenticationProvider } from "./userAuthenticationHandle";
 export declare const userAuthenticationProvider: (serverUrl: string, clientId: string) => AuthenticationProvider;

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

@@ -21,6 +21,7 @@ export const userAuthenticationProvider = (serverUrl, clientId) => {
         authUrl.searchParams.set('state', state);
         authUrl.searchParams.set('code_challenge', code_challenge);
         authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('scope', 'openid profile email user.extended properties');
         return { state, codeVerifier: code_verifier, authorisationUrl: authUrl.toString() };
     };
     const handleCallback = async (state, codeVerifier, callbackUrl) => {

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

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

package/dist/server-side/functionalSequence.js

@@ -5,6 +5,6 @@ import authorizationHandle from "./auth/authorizationHandle";
 import { userHandler } from "./handlers/userHandler";
 import { accessTokenHandler } from "./handlers/accessTokenHandler";
 import { sitemapHandle } from "./handlers/sitemapHandler";
-export const hookSequence = (secret, paraglideMiddleware, getTextDirection, settings, customHooks) => {
-    return sequence(userHandler(secret), accessTokenHandler(secret), paraglideHandler(paraglideMiddleware, getTextDirection), authorizationHandle(), sitemapHandle(settings), ...customHooks, errorHandler);
+export const hookSequence = (secret, redis, paraglideMiddleware, getTextDirection, settings, customHooks) => {
+    return sequence(accessTokenHandler(secret, redis), userHandler(), paraglideHandler(paraglideMiddleware, getTextDirection), authorizationHandle(), sitemapHandle(settings), ...customHooks, errorHandler);
 };

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

@@ -1,2 +1,3 @@
 import { type Handle } from '@sveltejs/kit';
-export declare const accessTokenHandler: (secret: string) => Handle;
+import { Redis } from '@upstash/redis';
+export declare const accessTokenHandler: (secret: string, redis: Redis) => Handle;

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

@@ -1,12 +1,14 @@
 import {} from '@sveltejs/kit';
 import { loadCookie } from '../cookies';
-const accessTokenCookie = "functionalcms_access_token";
-export const accessTokenHandler = (secret) => {
+import { Redis } from '@upstash/redis';
+const accessTokenCookie = "functionalcms_sessionId";
+export const accessTokenHandler = (secret, redis) => {
     return async ({ event, resolve }) => {
         try {
-            let token = await loadCookie(event.cookies, secret, accessTokenCookie);
-            if (token) {
-                event.locals.token = token;
+            let sessionId = await loadCookie(event.cookies, secret, accessTokenCookie);
+            if (sessionId) {
+                const accessToken = await redis.get(sessionId);
+                event.locals.token = accessToken;
             }
         }
         finally {

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

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

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

@@ -1,22 +1,13 @@
 import {} from '@sveltejs/kit';
 import { loadCookie } from '../cookies';
-const accessTokenCookie = "functionalcms_access_token";
-const retrieveUser = async (idToken) => {
-    const parts = idToken.split('.');
-    // Base64url to string conversion
-    const base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-    // Use TextDecoder (available in Node.js 11+)
-    const binString = globalThis.atob(base64);
-    const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
-    const payload = JSON.parse(new TextDecoder().decode(bytes));
-    return payload;
-};
-export const userHandler = (secret) => {
+import { Redis } from '@upstash/redis';
+import { parseJwtToken } from '../tokenToUserParser';
+const accessTokenCookie = "functionalcms_sessionId";
+export const userHandler = () => {
     return async ({ event, resolve }) => {
         try {
-            let idToken = await loadCookie(event.cookies, secret, accessTokenCookie);
-            if (idToken) {
-                let user = await retrieveUser(idToken);
+            if (event.locals.token) {
+                const user = parseJwtToken(event.locals.token);
                 event.locals.user = user;
             }
         }

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

@@ -0,0 +1 @@
+export declare function parseJwtToken(token: string): any;

package/dist/server-side/tokenToUserParser.js

@@ -0,0 +1,10 @@
+export function parseJwtToken(token) {
+    const base64 = token.split('.')[1]
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
+    const json = decodeURIComponent(atob(base64)
+        .split('')
+        .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+        .join(''));
+    return JSON.parse(json);
+}

package/package.json

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