@pikku/core 0.6.23 → 0.6.25

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## 0.6
 
+## 0.6.25
+
+### Patch Changes
+
+- b774c7d: fix: coerce top level data from schema now includes date strings
+
+## 0.6.24
+
+### Patch Changes
+
+- 531f4b5: refactor: using userSession.set to set cookies with middleware
+
 ## 0.6.23
 
 ### Patch Changes

package/dist/channel/channel-runner.d.ts

@@ -7,8 +7,8 @@ export declare const getMatchingChannelConfig: (request: string) => {
     channelConfig: CoreAPIChannel<any, string, import("./channel.types.js").CoreChannelConnection<any, unknown, import("../index.js").CoreServices>, import("./channel.types.js").CoreChannelDisconnection<any, import("../index.js").CoreServices>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../index.js").CoreServices> | import("../index.js").CoreAPIFunction<unknown, unknown>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../index.js").CoreServices> | import("../index.js").CoreAPIFunction<unknown, unknown>, import("../index.js").CoreAPIPermission<any>>;
     schemaName: string | null | undefined;
 } | null;
-export declare const openChannel: ({ route, singletonServices, coerceToArray, request, }: Pick<CoreAPIChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
-    userSessionService: UserSessionService<any>;
+export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreAPIChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
+    userSession: UserSessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreAPIChannel<unknown, any>;

package/dist/channel/channel-runner.js

@@ -1,6 +1,6 @@
 import { NotFoundError } from '../errors/errors.js';
 import { pikkuState } from '../pikku-state.js';
-import { coerceQueryStringToArray, validateSchema } from '../schema.js';
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { match } from 'path-to-regexp';
 export const addChannel = (channel) => {
     pikkuState('channel', 'channels').push(channel);
@@ -27,7 +27,7 @@ export const getMatchingChannelConfig = (request) => {
     }
     return null;
 };
-export const openChannel = async ({ route, singletonServices, coerceToArray = false, request, }) => {
+export const openChannel = async ({ route, singletonServices, coerceDataFromSchema = true, request, }) => {
     const matchingChannel = getMatchingChannelConfig(route);
     if (!matchingChannel) {
         singletonServices.logger.info(`Channel not found: ${route}`);
@@ -40,10 +40,10 @@ export const openChannel = async ({ route, singletonServices, coerceToArray = fa
     let openingData;
     if (request) {
         openingData = await request.data();
-        if (coerceToArray && schemaName) {
-            coerceQueryStringToArray(schemaName, openingData);
+        if (coerceDataFromSchema && schemaName) {
+            coerceTopLevelDataFromSchema(schemaName, openingData);
         }
-        await validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, openingData);
+        await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
     return { openingData, channelConfig };
 };

package/dist/channel/channel.types.d.ts

@@ -5,7 +5,7 @@ import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js'
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
-    coerceToArray: boolean;
+    coerceDataFromSchema: boolean;
     logWarningsForStatusCodes: number[];
     bubbleErrors: boolean;
 }>;

package/dist/channel/local/local-channel-runner.d.ts

@@ -1,3 +1,3 @@
 import { CoreAPIChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession, respondWith404, coerceToArray, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreAPIChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;
+export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreAPIChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;

package/dist/channel/local/local-channel-runner.js

@@ -6,10 +6,10 @@ import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleError } from '../../handle-error.js';
 import { runMiddleware } from '../../middleware-runner.js';
 import { PikkuUserSessionService } from '../../services/user-session-service.js';
-export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceToArray = false, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
+export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let sessionServices;
     let channelHandler;
-    const userSessionService = new PikkuUserSessionService();
+    const userSession = new PikkuUserSessionService();
     let http;
     if (request) {
         http = createHTTPInteraction(request, response);
@@ -26,19 +26,19 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 route,
                 singletonServices,
                 skipUserSession,
-                coerceToArray,
-                userSessionService,
+                coerceDataFromSchema,
+                userSession,
             });
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
-            const session = await userSessionService.get();
+            const session = await userSession.get();
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http }, session);
             }
             const allServices = {
                 ...singletonServices,
                 ...sessionServices,
-                userSession: userSessionService,
+                userSession: userSession,
             };
             channelHandler.registerOnOpen(() => {
                 channelConfig.onConnect?.(allServices, channel);
@@ -62,7 +62,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     };
     await runMiddleware({
         ...singletonServices,
-        userSessionService,
+        userSession,
     }, { http }, route.middleware || [], main);
     return channelHandler;
 };

package/dist/channel/serverless/serverless-channel-runner.d.ts

@@ -5,6 +5,6 @@ export interface RunServerlessChannelParams<ChannelData> extends RunChannelParam
     channelHandlerFactory: PikkuChannelHandlerFactory;
     channelObject?: unknown;
 }
-export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceToArray, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreAPIChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreAPIChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelDisconnect: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelMessage: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;

package/dist/channel/serverless/serverless-channel-runner.js

@@ -20,21 +20,21 @@ const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory,
         channel: channelHandler.getChannel(),
     };
 };
-export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceToArray = false, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
+export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
     let sessionServices;
     let http;
     if (request instanceof Request) {
         http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
     }
-    const userSessionService = new PikkuUserSessionService(channelStore, channelId);
+    const userSession = new PikkuUserSessionService(channelStore, channelId);
     const { channelConfig, openingData } = await openChannel({
         channelId,
         createSessionServices,
         request,
         route,
         singletonServices,
-        coerceToArray,
-        userSessionService,
+        coerceDataFromSchema,
+        userSession,
     });
     const main = async () => {
         try {
@@ -50,7 +50,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
                 channelName: channelConfig.name,
             });
             if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, await userSessionService.get());
+                sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
             }
             await channelConfig.onConnect?.({ ...singletonServices, ...sessionServices }, channel);
             http?.response?.status(101);
@@ -66,7 +66,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     };
     await runMiddleware({
         ...singletonServices,
-        userSessionService,
+        userSession,
     }, { http }, channelConfig.middleware || [], main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {

package/dist/http/http-route-runner.d.ts

@@ -87,4 +87,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @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 declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceToArray, bubbleErrors, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;

package/dist/http/http-route-runner.js

@@ -2,8 +2,8 @@ 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 { coerceQueryStringToArray, validateSchema } from '../schema.js';
-import { PikkuUserSessionService } from '../services/user-session-service.js';
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.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';
@@ -142,7 +142,7 @@ export const createHTTPInteraction = (request, response) => {
  */
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
     const { matchedPath, params, route, middleware, schemaName } = matchedRoute;
-    const { singletonServices, userSessionService, createSessionServices, skipUserSession, } = services;
+    const { singletonServices, userSession, createSessionServices, skipUserSession, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
     let result;
@@ -151,7 +151,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
     singletonServices.logger.info(`Matched route: ${route.route} | method: ${route.method.toUpperCase()} | auth: ${requiresSession.toString()}`);
     // Main route execution logic wrapped for middleware handling
     const runMain = async () => {
-        const session = userSessionService.get();
+        const session = userSession.get();
         // Ensure session is available when required
         if (skipUserSession && requiresSession) {
             throw new Error("Can't skip trying to get user session if auth is required");
@@ -164,18 +164,19 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             throw new MissingSessionError();
         }
         // Create session-specific services for handling the request
-        sessionServices = await createSessionServices({ ...singletonServices, userSessionService }, { http }, session);
+        sessionServices = await createSessionServices({ ...singletonServices, userSession }, { http }, session);
         const allServices = {
             ...singletonServices,
             ...sessionServices,
+            userSession,
             http,
         };
         const data = await http?.request?.data();
         // Validate request data against the defined schema, if any
-        await validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
-        // Coerce query string parameters to arrays if specified by the schema
-        if (options.coerceToArray && schemaName) {
-            coerceQueryStringToArray(schemaName, data);
+        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);
@@ -197,7 +198,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         return result;
     };
     // Execute middleware, then run the main logic
-    await runMiddleware({ ...singletonServices, userSessionService }, { http }, middleware, runMain);
+    await runMiddleware({ ...singletonServices, userSession }, { http }, middleware, runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**
@@ -255,8 +256,8 @@ 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 = [], coerceToArray = false, bubbleErrors = false, }) => {
-    const userSessionService = new PikkuUserSessionService();
+export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, }) => {
+    const userSession = new PikkuUserSessionService();
     let sessionServices;
     let result;
     // Combine the request and response into one interaction object
@@ -279,10 +280,10 @@ export const fetchData = async (request, response, { singletonServices, createSe
         ;
         ({ result, sessionServices } = await executeRouteWithMiddleware({
             singletonServices,
-            userSessionService,
+            userSession,
             createSessionServices,
             skipUserSession,
-        }, matchedRoute, http, { coerceToArray }));
+        }, matchedRoute, http, { coerceDataFromSchema }));
         return result;
     }
     catch (e) {

package/dist/http/http-routes.types.d.ts

@@ -8,7 +8,7 @@ export type RunRouteOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
     logWarningsForStatusCodes: number[];
-    coerceToArray: boolean;
+    coerceDataFromSchema: boolean;
     bubbleErrors: boolean;
 }>;
 export type RunRouteParams = {

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

@@ -51,4 +51,5 @@ export declare class PikkuFetchHTTPRequest<In = unknown> implements PikkuHTTPReq
      * @returns A promise that resolves to an object containing the combined data.
      */
     data(): Promise<In>;
+    private body;
 }

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

@@ -1,5 +1,6 @@
 import { parse as parseQuery } from 'picoquery';
 import { parse as parseCookie } from 'cookie';
+import { UnprocessableContentError } from '../errors/errors.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.
@@ -77,16 +78,71 @@ export class PikkuFetchHTTPRequest {
      * @returns A promise that resolves to an object containing the combined data.
      */
     async data() {
+        const body = await this.body();
+        const parts = [this.params(), this.query(), body];
+        const merged = {};
+        for (const part of parts) {
+            for (const [key, value] of Object.entries(part)) {
+                if (key in merged && !valuesAreEquivalent(merged[key], value)) {
+                    throw new UnprocessableContentError(`Conflicting values for key "${key}": "${merged[key]}" vs "${value}"`);
+                }
+                merged[key] ??= value;
+            }
+        }
+        return merged;
+    }
+    async body() {
+        const noBodyMethods = ['get', 'head', 'options'];
+        if (noBodyMethods.includes(this.method())) {
+            return {};
+        }
         let body = {};
+        const contentType = this.header('content-type') || '';
         try {
-            body = await this.json();
+            if (contentType.includes('application/json')) {
+                const parsed = await this.json();
+                body =
+                    typeof parsed === 'object' &&
+                        parsed !== null &&
+                        !Array.isArray(parsed)
+                        ? parsed
+                        : { data: parsed };
+            }
+            else if (contentType.includes('text/')) {
+                const text = await this.request.text();
+                body = { data: text };
+            }
+            else if (contentType.includes('application/octet-stream')) {
+                const buffer = await this.request.arrayBuffer();
+                body = { data: buffer };
+            }
+            else if (contentType === 'application/x-www-form-urlencoded') {
+                const text = await this.request.text();
+                body = Object.fromEntries(new URLSearchParams(text));
+            }
+            else {
+                throw new UnprocessableContentError(`Unsupported content type ${contentType}`);
+            }
+        }
+        catch (e) {
+            throw new UnprocessableContentError(`Error parsing body: ${e}`);
         }
-        catch (e) { }
-        return {
-            ...this.params(),
-            ...this.query(),
-            // TODO: If body isn't an object, we should insert it as the word...
-            ...body,
-        };
+        return body;
+    }
+}
+function valuesAreEquivalent(a, b) {
+    return coerce(a) === coerce(b);
+}
+function coerce(value) {
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        const num = Number(value);
+        return isNaN(num) ? value : num;
     }
+    return value;
 }

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

@@ -1,8 +1,9 @@
 import { PikkuHTTPResponse } from './http-routes.types.js';
+import { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
     status(code: number): this;
-    cookie(name: string, value: string, flags: any): this;
+    cookie(name: string, value: string, flags: CookieSerializeOptions): this;
     header(name: string, value: string | string[]): this;
     arrayBuffer(data: XMLHttpRequestBodyInit): this;
     json(data: unknown): this;

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

@@ -1,13 +1,15 @@
+import { serialize as serializeCookie, } from 'cookie';
 export class PikkuFetchHTTPResponse {
     #statusCode = 200;
     #headers = new Headers();
+    #cookies = new Map();
     #body = null;
     status(code) {
         this.#statusCode = code;
         return this;
     }
     cookie(name, value, flags) {
-        // TODO
+        this.#cookies.set(name, { value, flags });
         return this;
     }
     header(name, value) {
@@ -50,6 +52,8 @@ export class PikkuFetchHTTPResponse {
         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(', '));
         return new Response(this.#body, {
             ...args,
             status: this.#statusCode,

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export * from './channel/index.js';
 export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
+export * from './time-utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
 export { addRoute, addMiddleware } from './http/http-route-runner.js';

package/dist/index.js

@@ -11,6 +11,7 @@ export * from './channel/index.js';
 export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
+export * from './time-utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
 export { addRoute, addMiddleware } from './http/http-route-runner.js';

package/dist/middleware/auth-apikey.js

@@ -5,7 +5,7 @@
  */
 export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSessionService.get()) {
+        if (!http?.request || services.userSession.get()) {
             return next();
         }
         let apiKey = null;
@@ -27,7 +27,7 @@ export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
                 userSession = await getSessionForAPIKey(services, apiKey);
             }
             if (userSession) {
-                services.userSessionService.setInitial(userSession);
+                services.userSession.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-bearer.js

@@ -5,7 +5,7 @@ import { InvalidSessionError } from '../errors/errors.js';
 export const authBearer = ({ token, jwt, getSession, } = {}) => {
     const middleware = async (services, { http }, next) => {
         // Skip if session already exists.
-        if (!http?.request || services.userSessionService.get()) {
+        if (!http?.request || services.userSession.get()) {
             return next();
         }
         const authHeader = http.request.header('authorization') ||
@@ -31,7 +31,7 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
                 userSession = await getSession(services, token);
             }
             if (userSession) {
-                services.userSessionService.setInitial(userSession);
+                services.userSession.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-cookie.d.ts

@@ -1,12 +1,16 @@
+import { SerializeOptions } from 'cookie';
 import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+import { RelativeTimeInput } from '../time-utils.js';
 /**
  * Cookie middleware that extracts a session from cookies.
  *
- * @param options.cookieNames - List of cookie names to check.
+ * @param options.name - List of cookie names to check.
  * @param options.getSessionForCookieValue - Function to retrieve a session using a cookie value.
  */
-export declare const authCookie: <SingletonServices extends CoreSingletonServices<CoreConfig>, UserSession extends CoreUserSession>({ cookieNames, getSessionForCookieValue, jwt, }: {
-    cookieNames: string[];
+export declare const authCookie: <SingletonServices extends CoreSingletonServices<CoreConfig>, UserSession extends CoreUserSession>({ name, getSessionForCookieValue, jwt, options, expiresIn, }: {
+    name: string;
+    options: SerializeOptions;
+    expiresIn: RelativeTimeInput;
 } & ({
     getSessionForCookieValue: (services: SingletonServices, cookieValue: string, cookieName: string) => Promise<UserSession>;
     jwt?: false;

package/dist/middleware/auth-cookie.js

@@ -1,34 +1,51 @@
+import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
 /**
  * Cookie middleware that extracts a session from cookies.
  *
- * @param options.cookieNames - List of cookie names to check.
+ * @param options.name - List of cookie names to check.
  * @param options.getSessionForCookieValue - Function to retrieve a session using a cookie value.
  */
-export const authCookie = ({ cookieNames, getSessionForCookieValue, jwt, }) => {
+export const authCookie = ({ name, getSessionForCookieValue, jwt, options, expiresIn, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSessionService.get()) {
+        if (!http?.request || services.userSession.get()) {
             return next();
         }
         let userSession = null;
-        for (const cookieName of cookieNames) {
-            const cookieValue = http.request.cookie(cookieName);
-            if (cookieValue) {
-                if (jwt) {
-                    if (!services.jwt) {
-                        throw new Error('JWT service is required for JWT decoding.');
-                    }
-                    userSession = await services.jwt.decode(cookieValue);
+        const cookieValue = http.request.cookie(name);
+        if (cookieValue) {
+            if (jwt) {
+                if (!services.jwt) {
+                    throw new Error('JWT service is required for JWT decoding.');
                 }
-                else if (getSessionForCookieValue) {
-                    userSession = await getSessionForCookieValue(services, cookieValue, cookieName);
-                }
-                break;
+                userSession = await services.jwt.decode(cookieValue);
+            }
+            else if (getSessionForCookieValue) {
+                userSession = await getSessionForCookieValue(services, cookieValue, name);
             }
         }
         if (userSession) {
-            services.userSessionService.setInitial(userSession);
+            services.userSession.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 (jwt) {
+                if (!services.jwt) {
+                    throw new Error('JWT service is required for JWT encoding.');
+                }
+                http.response.cookie(name, await services.jwt.encode(expiresIn, session), {
+                    ...options,
+                    expires: getRelativeTimeOffsetFromNow(expiresIn),
+                });
+            }
+            else {
+                services.logger.warn('No JWT service available, unable to set cookie');
+            }
         }
-        return next();
     };
     return middleware;
 };

package/dist/middleware-runner.d.ts

@@ -3,7 +3,7 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
- * @param services - An object containing services (e.g., singletonServices, userSessionService, etc.)
+ * @param services - An object containing services (e.g., singletonServices, userSession, etc.)
  * @param interaction - The interaction context, e.g., { http }.
  * @param middlewares - An array of middleware functions to run.
  * @param main - The main function to execute after all middleware have run.
@@ -11,12 +11,12 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
  *
  * @example
  * runMiddleware(
- *   { ...services, userSessionService },
+ *   { ...services, userSession },
  *   { http },
  *   [middleware1, middleware2, middleware3],
  *   async () => { return await runMain(); }
  * );
  */
 export declare const runMiddleware: (services: CoreSingletonServices & {
-    userSessionService: UserSessionService<any>;
+    userSession: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: PikkuMiddleware[], main?: () => Promise<void>) => Promise<void>;

package/dist/middleware-runner.js

@@ -1,7 +1,7 @@
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
- * @param services - An object containing services (e.g., singletonServices, userSessionService, etc.)
+ * @param services - An object containing services (e.g., singletonServices, userSession, etc.)
  * @param interaction - The interaction context, e.g., { http }.
  * @param middlewares - An array of middleware functions to run.
  * @param main - The main function to execute after all middleware have run.
@@ -9,7 +9,7 @@
  *
  * @example
  * runMiddleware(
- *   { ...services, userSessionService },
+ *   { ...services, userSession },
  *   { http },
  *   [middleware1, middleware2, middleware3],
  *   async () => { return await runMain(); }

package/dist/schema.d.ts

@@ -12,5 +12,5 @@ export declare const addSchema: (name: string, value: any) => void;
  * @param logger - A logger for logging information.
  */
 export declare const compileAllSchemas: (logger: Logger, schemaService?: SchemaService) => void;
-export declare const coerceQueryStringToArray: (schemaName: string, data: any) => void;
+export declare const coerceTopLevelDataFromSchema: (schemaName: string, data: any) => void;
 export declare const validateSchema: (logger: Logger, schemaService: SchemaService | undefined, schemaName: string | undefined | null, data: any) => Promise<void>;

package/dist/schema.js

@@ -42,7 +42,7 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
         logger.info('All schemas loaded');
     }
 };
-export const coerceQueryStringToArray = (schemaName, data) => {
+export const coerceTopLevelDataFromSchema = (schemaName, data) => {
     const schema = pikkuState('misc', 'schemas').get(schemaName);
     for (const key in schema.properties) {
         const property = schema.properties[key];
@@ -56,6 +56,9 @@ export const coerceQueryStringToArray = (schemaName, data) => {
         if (type === 'array' && typeof data[key] === 'string') {
             data[key] = data[key].split(',');
         }
+        else if (type === 'string' && property.format === 'date-time') {
+            data[key] = new Date(data[key]);
+        }
     }
 };
 export const validateSchema = async (logger, schemaService, schemaName, data) => {