@pikku/core 0.6.27 → 0.7.1

package/dist/http/{http-route-runner.js → http-runner.js}

@@ -1,14 +1,13 @@
-import { verifyPermissions } from '../permissions.js';
 import { match } from 'path-to-regexp';
-import { ForbiddenError, MissingSessionError, NotFoundError, } from '../errors/errors.js';
-import { closeSessionServices } from '../utils.js';
-import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
+import { MissingSessionError, NotFoundError } from '../errors/errors.js';
+import { closeSessionServices, createWeakUID, isSerializable, } from '../utils.js';
 import { PikkuUserSessionService, } from '../services/user-session-service.js';
 import { runMiddleware } from '../middleware-runner.js';
 import { handleError } from '../handle-error.js';
 import { pikkuState } from '../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+import { addFunction, runPikkuFunc } from '../function/function-runner.js';
 /**
  * Registers middleware either globally or for a specific route.
  *
@@ -45,12 +44,24 @@ export const addMiddleware = (routeOrMiddleware, middleware) => {
  * @template Route Route pattern as a string.
  * @template APIFunction Type for the route handler function.
  * @template APIFunctionSessionless Type for a sessionless handler.
- * @template APIPermission Type representing required permissions.
+ * @template APIPermissionGroup Type representing required permissions.
  * @template APIMiddleware Middleware type to be used with the route.
  * @param {CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>} route - The route configuration object.
  */
-export const addRoute = (route) => {
-    pikkuState('http', 'routes').push(route);
+export const addHTTPRoute = (httpRoute) => {
+    const httpMeta = pikkuState('http', 'meta');
+    const routeMeta = httpMeta.find((meta) => meta.route === httpRoute.route && meta.method === httpRoute.method);
+    if (!routeMeta) {
+        throw new Error('Route metadata not found');
+    }
+    addFunction(routeMeta.pikkuFuncName, httpRoute.func);
+    const routes = pikkuState('http', 'routes');
+    if (!routes.has(httpRoute.method)) {
+        routes.set(httpRoute.method, new Map());
+    }
+    pikkuState('http', 'routes')
+        .get(httpRoute.method)
+        ?.set(httpRoute.route, httpRoute);
 };
 /**
  * Finds a matching route based on the HTTP method and URL path.
@@ -64,14 +75,13 @@ export const addRoute = (route) => {
  * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType, requestPath) => {
-    const routes = pikkuState('http', 'routes');
+    const allRoutes = pikkuState('http', 'routes');
     const middleware = pikkuState('http', 'middleware');
-    const routesMeta = pikkuState('http', 'meta');
-    for (const route of routes) {
-        // Skip routes that don't match the HTTP method
-        if (route.method !== requestType.toLowerCase()) {
-            continue;
-        }
+    const routes = allRoutes.get(requestType.toLowerCase());
+    if (!routes) {
+        return undefined;
+    }
+    for (const route of routes.values()) {
         // Generate a matching function from the route pattern
         const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
             decode: decodeURIComponent,
@@ -84,14 +94,14 @@ const getMatchingRoute = (requestType, requestPath) => {
                 .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
                 .map((m) => m.middleware)
                 .flat();
-            // Extract associated schema information if available
-            const schemaName = routesMeta.find((routeMeta) => routeMeta.method === route.method && routeMeta.route === route.route)?.input;
+            const meta = pikkuState('http', 'meta').find((meta) => meta.route === route.route && meta.method === route.method);
             return {
                 matchedPath,
                 params: matchedPath.params,
                 route,
+                permissions: route.permissions,
                 middleware: [...globalMiddleware, ...(route.middleware || [])],
-                schemaName,
+                meta: meta,
             };
         }
     }
@@ -141,8 +151,8 @@ export const createHTTPInteraction = (request, response) => {
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
-    const { matchedPath, params, route, middleware, schemaName } = matchedRoute;
-    const { singletonServices, userSession, createSessionServices, skipUserSession, } = services;
+    const { matchedPath, params, route, middleware, meta } = matchedRoute;
+    const { singletonServices, userSession, createSessionServices, skipUserSession, requestId, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
     let result;
@@ -163,28 +173,53 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             });
             throw new MissingSessionError();
         }
-        // Create session-specific services for handling the request
-        sessionServices = await createSessionServices({ ...singletonServices, userSession }, { http }, session);
-        const allServices = {
-            ...singletonServices,
-            ...sessionServices,
-            userSession,
-            http,
+        const data = http.request.data();
+        const getAllServices = async () => {
+            let channel;
+            if (matchedRoute.route.sse) {
+                const response = http?.response;
+                if (!response) {
+                    throw new Error('SSE requires a valid HTTP response object');
+                }
+                if (!response.setMode) {
+                    throw new Error('Response object does not support SSE mode');
+                }
+                response.setMode('stream');
+                response.header('Content-Type', 'text/event-stream');
+                response.header('Cache-Control', 'no-cache');
+                response.header('Connection', 'keep-alive');
+                response.header('Transfer-Encoding', 'chunked');
+                channel = {
+                    channelId: requestId,
+                    openingData: data,
+                    send: (data) => {
+                        response.arrayBuffer(isSerializable(data) ? JSON.stringify(data) : data);
+                    },
+                    close: () => {
+                        channel.state = 'closed';
+                        response.close?.();
+                    },
+                    state: 'open',
+                };
+            }
+            // Create session-specific services for handling the request
+            sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
+            return {
+                ...singletonServices,
+                ...sessionServices,
+                http,
+                userSession,
+                channel,
+            };
         };
-        const data = await http?.request?.data();
-        // Validate request data against the defined schema, if any
-        await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, data);
-        // Coerce (top level) query string parameters or date objects if specified by the schema
-        if (options.coerceDataFromSchema && schemaName) {
-            coerceTopLevelDataFromSchema(schemaName, data);
-        }
-        // Execute permission checks
-        const permissioned = await verifyPermissions(route.permissions, allServices, data, session);
-        if (permissioned === false) {
-            throw new ForbiddenError('Permission denied');
-        }
-        // Invoke the actual route handler function
-        result = await route.func(allServices, data, session);
+        const result = await runPikkuFunc(meta.pikkuFuncName, {
+            singletonServices,
+            getAllServices,
+            session,
+            data,
+            permissions: route.permissions,
+            coerceDataFromSchema: options.coerceDataFromSchema,
+        });
         // Respond with either a binary or JSON response based on configuration
         if (route.returnsJSON === false) {
             http?.response?.arrayBuffer(result);
@@ -256,7 +291,10 @@ export const pikkuFetch = async (request, params) => {
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, }) => {
+export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
+    const requestId = request.getHeader?.('x-request-id') ||
+        generateRequestId?.() ||
+        createWeakUID();
     const userSession = new PikkuUserSessionService();
     let sessionServices;
     let result;
@@ -283,13 +321,13 @@ export const fetchData = async (request, response, { singletonServices, createSe
             userSession,
             createSessionServices,
             skipUserSession,
+            requestId,
         }, matchedRoute, http, { coerceDataFromSchema }));
         return result;
     }
     catch (e) {
         // Handle errors and, depending on configuration, bubble them up or respond with an error
-        handleError(e, http, '111', // TODO: context.get('trackingId'),
-        singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        handleError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
         // Clean up any session-specific services created during processing

package/dist/http/{http-routes.types.d.ts → http.types.d.ts}

@@ -1,7 +1,7 @@
-import { SerializeOptions } from 'cookie';
-import { PikkuError } from '../errors/error-handler.js';
-import { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../types/functions.types.js';
+import type { SerializeOptions } from 'cookie';
+import type { PikkuError } from '../errors/error-handler.js';
+import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
+import type { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, CorePermissionGroup } from '../function/functions.types.js';
 type ExtractRouteParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertRouteParams<In, Route extends string> = ExtractRouteParams<Route> extends keyof In ? unknown : ['Error: Route parameters', ExtractRouteParams<Route>, 'not in', keyof In];
 export type RunRouteOptions = Partial<{
@@ -10,6 +10,7 @@ export type RunRouteOptions = Partial<{
     logWarningsForStatusCodes: number[];
     coerceDataFromSchema: boolean;
     bubbleErrors: boolean;
+    generateRequestId: () => string;
 }>;
 export type RunRouteParams = {
     singletonServices: CoreSingletonServices;
@@ -64,10 +65,11 @@ export type CoreHTTPFunctionRoute<In, Out, R extends string, APIFunction = CoreA
     route: R;
     method: HTTPMethod;
     func: APIFunction;
-    permissions?: Record<string, APIPermission[] | APIPermission>;
+    permissions?: CorePermissionGroup<APIPermission>;
     auth?: true;
     tags?: string[];
     middleware?: APIMiddleware[];
+    sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
     method: HTTPMethod;
@@ -76,15 +78,35 @@ export type CoreHTTPFunctionRoute<In, Out, R extends string, APIFunction = CoreA
     auth?: false;
     tags?: string[];
     middleware?: APIMiddleware[];
+    sse?: undefined;
+}) | (CoreHTTPFunction & {
+    route: R;
+    method: 'get';
+    func: APIFunction;
+    permissions?: CorePermissionGroup<APIPermission>;
+    auth?: true;
+    sse?: boolean;
+    tags?: string[];
+    middleware?: APIMiddleware[];
+}) | (CoreHTTPFunction & {
+    route: R;
+    method: 'get';
+    func: APIFunctionSessionless;
+    permissions?: undefined;
+    auth?: false;
+    sse?: boolean;
+    tags?: string[];
+    middleware?: APIMiddleware[];
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'post';
     func: APIFunction;
-    permissions?: Record<string, APIPermission[] | APIPermission>;
+    permissions?: CorePermissionGroup<APIPermission>;
     auth?: true;
     query?: Array<keyof In>;
     tags?: string[];
     middleware?: APIMiddleware[];
+    sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'post';
@@ -94,11 +116,8 @@ export type CoreHTTPFunctionRoute<In, Out, R extends string, APIFunction = CoreA
     query?: Array<keyof In>;
     tags?: string[];
     middleware?: APIMiddleware[];
+    sse?: undefined;
 });
-/**
- * Represents an array of core API routes.
- */
-export type CoreHTTPFunctionRoutes = Array<CoreHTTPFunctionRoute<any, any, string>>;
 /**
  * Represents the input types for route metadata, including parameters, query, and body types.
  */
@@ -110,7 +129,8 @@ export type HTTPFunctionMetaInputTypes = {
 /**
  * Represents metadata for a set of routes, including route details, methods, input/output types, and documentation.
  */
-export type HTTPRoutesMeta = Array<{
+export type HTTPRouteMeta = {
+    pikkuFuncName: string;
     route: string;
     method: HTTPMethod;
     params?: string[];
@@ -120,6 +140,13 @@ export type HTTPRoutesMeta = Array<{
     inputTypes?: HTTPFunctionMetaInputTypes;
     docs?: APIDocs;
     tags?: string[];
+    sse?: true;
+};
+export type HTTPRoutesMeta = Array<HTTPRouteMeta>;
+export type HTTPFunctionsMeta = Array<{
+    name: string;
+    inputs: string[] | null;
+    outputs: string[] | null;
 }>;
 export type HTTPRouteMiddleware = {
     route: string;
@@ -141,8 +168,10 @@ export interface PikkuHTTPResponse {
     status(code: number): this;
     cookie(name: string, value: string | null, options: SerializeOptions): this;
     header(name: string, value: string | string[]): this;
-    arrayBuffer(data: XMLHttpRequestBodyInit): this;
+    arrayBuffer(data: ArrayBuffer | ArrayBufferView | Blob | string | FormData | URLSearchParams | ReadableStream): this;
     json(data: unknown): this;
     redirect(location: string, status?: number): this;
+    close?: () => void;
+    setMode?: (mode: 'stream') => void;
 }
 export {};

package/dist/http/index.d.ts

@@ -2,5 +2,5 @@ export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
 export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
-export { fetch, fetchData, addRoute } from './http-route-runner.js';
-export type * from './http-routes.types.js';
+export { fetch, fetchData, addHTTPRoute } from './http-runner.js';
+export type * from './http.types.js';

package/dist/http/index.js

@@ -2,4 +2,4 @@ export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
 export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
-export { fetch, fetchData, addRoute } from './http-route-runner.js';
+export { fetch, fetchData, addHTTPRoute } from './http-runner.js';

package/dist/http/log-http-routes.js

@@ -4,14 +4,16 @@ import { pikkuState } from '../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger) => {
-    const routes = pikkuState('http', 'routes');
-    if (routes.length === 0) {
+    const routesByType = pikkuState('http', 'routes');
+    if (routesByType.size === 0) {
         logger.info('No routes added');
         return;
     }
     let routesMessage = 'Routes loaded:';
-    for (const { method, route } of routes) {
-        routesMessage += `\n\t- ${method.toUpperCase()} -> ${route}`;
-    }
+    routesByType.forEach((routes) => {
+        routes.forEach((route) => {
+            routesMessage += `\n\t- ${route.method.toUpperCase()} -> ${route.route}`;
+        });
+    });
     logger.info(routesMessage);
 };

package/dist/http/pikku-fetch-http-request.d.ts

@@ -1,4 +1,4 @@
-import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http-routes.types.js';
+import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.

package/dist/http/pikku-fetch-http-response.d.ts

@@ -1,7 +1,8 @@
-import { PikkuHTTPResponse } from './http-routes.types.js';
+import { PikkuHTTPResponse } from './http.types.js';
 import { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
+    setMode(mode: 'stream'): void;
     status(code: number): this;
     cookie(name: string, value: string, flags: CookieSerializeOptions): this;
     header(name: string, value: string | string[]): this;
@@ -9,7 +10,8 @@ export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     json(data: unknown): this;
     text(content: string): this;
     html(content: string): this;
-    body(body: BodyInit): this;
     redirect(location: string, status?: number): this;
+    close(): this;
     toResponse(args?: Record<string, any>): Response;
+    private createStream;
 }

package/dist/http/pikku-fetch-http-response.js

@@ -4,6 +4,15 @@ export class PikkuFetchHTTPResponse {
     #headers = new Headers();
     #cookies = new Map();
     #body = null;
+    #responseMode = null;
+    #send = null;
+    #close = null;
+    setMode(mode) {
+        this.#responseMode = 'stream';
+        if (mode === 'stream') {
+            this.#body = this.createStream();
+        }
+    }
     status(code) {
         this.#statusCode = code;
         return this;
@@ -23,34 +32,60 @@ export class PikkuFetchHTTPResponse {
         return this;
     }
     arrayBuffer(data) {
-        this.#body = data;
-        this.header('Content-Type', 'application/octet-stream');
+        if (this.#responseMode === 'stream') {
+            this.#send(data);
+        }
+        else {
+            this.#body = data;
+            this.header('Content-Type', 'application/octet-stream');
+        }
         return this;
     }
     json(data) {
-        this.#body = JSON.stringify(data);
-        this.header('Content-Type', 'application/json');
+        if (this.#responseMode === 'stream') {
+            this.#send(JSON.stringify(data));
+        }
+        else {
+            this.#body = JSON.stringify(data);
+            this.header('Content-Type', 'application/json');
+        }
         return this;
     }
     text(content) {
-        this.#body = content;
-        this.header('Content-Type', 'text/plain');
+        if (this.#responseMode === 'stream') {
+            this.#send(content);
+        }
+        else {
+            this.#body = content;
+            this.header('Content-Type', 'text/plain');
+        }
         return this;
     }
     html(content) {
-        this.#body = content;
-        this.header('Content-Type', 'text/html');
-        return this;
-    }
-    body(body) {
-        this.#body = body;
+        if (this.#responseMode === 'stream') {
+            this.#send(content);
+        }
+        else {
+            this.#body = content;
+            this.header('Content-Type', 'text/html');
+        }
         return this;
     }
+    // public body(body: BodyInit): this {
+    //   this.#body = body
+    //   return this
+    // }
     redirect(location, status = 302) {
         this.#statusCode = status;
         this.header('Location', location);
         return this;
     }
+    close() {
+        if (this.#close) {
+            this.#close();
+        }
+        return this;
+    }
     toResponse(args) {
         const cookieHeader = Array.from(this.#cookies.entries()).map(([name, { value, flags }]) => serializeCookie(name, value, flags));
         this.#headers.set('Set-Cookie', cookieHeader.join(', '));
@@ -60,4 +95,21 @@ export class PikkuFetchHTTPResponse {
             headers: this.#headers,
         });
     }
+    createStream() {
+        const encoder = new TextEncoder();
+        return new ReadableStream({
+            start: (controller) => {
+                const send = (data) => {
+                    controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                };
+                const close = () => {
+                    controller.close();
+                };
+                this.#send = send;
+                this.#close = close;
+                // Force initial flush
+                controller.enqueue(encoder.encode(':\n\n'));
+            },
+        });
+    }
 }

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * @module @pikku/core
  */
 export * from './types/core.types.js';
-export * from './types/functions.types.js';
+export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
 export * from './services/index.js';
@@ -12,8 +12,9 @@ export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
+export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute, addMiddleware } from './http/http-route-runner.js';
+export { addHTTPRoute, addMiddleware } from './http/http-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/index.js

@@ -2,7 +2,7 @@
  * @module @pikku/core
  */
 export * from './types/core.types.js';
-export * from './types/functions.types.js';
+export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
 export * from './services/index.js';
@@ -12,8 +12,9 @@ export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
+export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute, addMiddleware } from './http/http-route-runner.js';
+export { addHTTPRoute, addMiddleware } from './http/http-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/middleware/auth-apikey.js

@@ -5,7 +5,8 @@
  */
 export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        const { userSession: userSessionService, jwt: jwtService } = services;
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         let apiKey = null;
@@ -18,16 +19,16 @@ export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
         if (apiKey) {
             let userSession = null;
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(apiKey);
+                userSession = await jwtService.decode(apiKey);
             }
             else {
                 userSession = await getSessionForAPIKey(services, apiKey);
             }
             if (userSession) {
-                services.userSession.setInitial(userSession);
+                userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-bearer.js

@@ -4,8 +4,9 @@ import { InvalidSessionError } from '../errors/errors.js';
  */
 export const authBearer = ({ token, jwt, getSession, } = {}) => {
     const middleware = async (services, { http }, next) => {
+        const { userSession: userSessionService, jwt: jwtService } = services;
         // Skip if session already exists.
-        if (!http?.request || services.userSession.get()) {
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         const authHeader = http.request.header('authorization') ||
@@ -17,10 +18,10 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
             }
             let userSession = null;
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(bearerToken);
+                userSession = await jwtService.decode(bearerToken);
             }
             else if (token) {
                 if (bearerToken === token.value) {
@@ -31,7 +32,7 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
                 userSession = await getSession(services, token);
             }
             if (userSession) {
-                services.userSession.setInitial(userSession);
+                userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-cookie.js

@@ -7,43 +7,44 @@ import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
  */
 export const authCookie = ({ name, getSessionForCookieValue, jwt, options, expiresIn, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        const { userSession: userSessionService, jwt: jwtService, logger, } = services;
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         let userSession = null;
         const cookieValue = http.request.cookie(name);
         if (cookieValue) {
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(cookieValue);
+                userSession = await jwtService.decode(cookieValue);
             }
             else if (getSessionForCookieValue) {
                 userSession = await getSessionForCookieValue(services, cookieValue, name);
             }
         }
         if (userSession) {
-            services.userSession.setInitial(userSession);
+            userSessionService.setInitial(userSession);
         }
         await next();
         // Set the cookie in the response if the session has changed
         if (!http?.response) {
             return;
         }
-        if (services.userSession.sessionChanged) {
-            const session = services.userSession.get();
+        if (userSessionService.sessionChanged) {
+            const session = userSessionService.get();
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT encoding.');
                 }
-                http.response.cookie(name, await services.jwt.encode(expiresIn, session), {
+                http.response.cookie(name, await jwtService.encode(expiresIn, session), {
                     ...options,
                     expires: getRelativeTimeOffsetFromNow(expiresIn),
                 });
             }
             else {
-                services.logger.warn('No JWT service available, unable to set cookie');
+                logger.warn('No JWT service available, unable to set cookie');
             }
         }
     };