@pikku/core 0.6.22 → 0.6.24

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## 0.6
 
+## 0.6.24
+
+### Patch Changes
+
+- 531f4b5: refactor: using userSession.set to set cookies with middleware
+
+## 0.6.23
+
+### Patch Changes
+
+- 1c8c470: fix: await schema validation
+
 ## 0.6.22
 
 ### Patch Changes

package/dist/channel/channel-handler.js

@@ -71,7 +71,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         }
         const routeMeta = getRouteMeta(channelConfig.name, routingProperty, routerValue);
         if (routeMeta) {
-            validateSchema(services.logger, data, routeMeta);
+            await validateSchema(services.logger, data, routeMeta);
         }
         const hasPermission = await validatePermissions(services, channelHandler, onMessage, data);
         if (!hasPermission) {

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

@@ -8,7 +8,7 @@ export declare const getMatchingChannelConfig: (request: string) => {
     schemaName: string | null | undefined;
 } | null;
 export declare const openChannel: ({ route, singletonServices, coerceToArray, request, }: Pick<CoreAPIChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
-    userSessionService: UserSessionService<any>;
+    userSession: UserSessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreAPIChannel<unknown, any>;

package/dist/channel/channel-runner.js

@@ -43,7 +43,7 @@ export const openChannel = async ({ route, singletonServices, coerceToArray = fa
         if (coerceToArray && schemaName) {
             coerceQueryStringToArray(schemaName, openingData);
         }
-        validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, openingData);
+        await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
     return { openingData, channelConfig };
 };

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

@@ -9,7 +9,7 @@ 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, }) => {
     let sessionServices;
     let channelHandler;
-    const userSessionService = new PikkuUserSessionService();
+    const userSession = new PikkuUserSessionService();
     let http;
     if (request) {
         http = createHTTPInteraction(request, response);
@@ -27,18 +27,18 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 singletonServices,
                 skipUserSession,
                 coerceToArray,
-                userSessionService,
+                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.js

@@ -26,7 +26,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     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,
@@ -34,7 +34,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         route,
         singletonServices,
         coerceToArray,
-        userSessionService,
+        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.js

@@ -3,7 +3,7 @@ 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 { 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,21 +164,16 @@ 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
-        try {
-            console.log(schemaName, data);
-            validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
-        }
-        catch (e) {
-            // TODO: Implement proper handling for schema validation failures
-        }
+        await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, data);
         // Coerce query string parameters to arrays if specified by the schema
         if (options.coerceToArray && schemaName) {
             coerceQueryStringToArray(schemaName, data);
@@ -203,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 };
 };
 /**
@@ -262,7 +257,7 @@ export const pikkuFetch = async (request, params) => {
  * @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();
+    const userSession = new PikkuUserSessionService();
     let sessionServices;
     let result;
     // Combine the request and response into one interaction object
@@ -285,7 +280,7 @@ export const fetchData = async (request, response, { singletonServices, createSe
         ;
         ({ result, sessionServices } = await executeRouteWithMiddleware({
             singletonServices,
-            userSessionService,
+            userSession,
             createSessionServices,
             skipUserSession,
         }, matchedRoute, http, { coerceToArray }));

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/services/jwt-service.d.ts

@@ -1,3 +1,4 @@
+import { RelativeTimeInput } from '../time-utils.js';
 /**
  * Interface for handling JSON Web Tokens (JWT).
  */
@@ -8,7 +9,7 @@ export interface JWTService {
      * @param payload - The payload to encode.
      * @returns A promise that resolves to the encoded JWT.
      */
-    encode: <T extends any>(expiresIn: string, payload: T) => Promise<string>;
+    encode: <T extends any>(expiresIn: RelativeTimeInput, payload: T) => Promise<string>;
     /**
      * Decodes a JWT into its payload.
      * @param hash - The JWT to decode.

package/dist/services/local-secrets.d.ts

@@ -4,11 +4,11 @@ import { VariablesService } from './variables-service.js';
  * Service for retrieving secrets from environment variables.
  */
 export declare class LocalSecretService implements SecretService {
-    private variablesService;
+    private variables;
     /**
      * Creates an instance of LocalSecretService.
      */
-    constructor(variablesService?: VariablesService);
+    constructor(variables?: VariablesService);
     /**
      * Retrieves a secret by key.
      * @param key - The key of the secret to retrieve.

package/dist/services/local-secrets.js

@@ -3,12 +3,12 @@ import { LocalVariablesService } from './local-variables.js';
  * Service for retrieving secrets from environment variables.
  */
 export class LocalSecretService {
-    variablesService;
+    variables;
     /**
      * Creates an instance of LocalSecretService.
      */
-    constructor(variablesService = new LocalVariablesService()) {
-        this.variablesService = variablesService;
+    constructor(variables = new LocalVariablesService()) {
+        this.variables = variables;
     }
     /**
      * Retrieves a secret by key.
@@ -17,7 +17,7 @@ export class LocalSecretService {
      * @throws {Error} If the secret is not found.
      */
     async getSecretJSON(key) {
-        const value = await this.variablesService.get(key);
+        const value = await this.variables.get(key);
         if (value) {
             return JSON.parse(value);
         }
@@ -30,7 +30,7 @@ export class LocalSecretService {
      * @throws {Error} If the secret is not found.
      */
     async getSecret(key) {
-        const value = await this.variablesService.get(key);
+        const value = await this.variables.get(key);
         if (value) {
             return value;
         }

package/dist/services/user-session-service.d.ts

@@ -1,6 +1,7 @@
 import { ChannelStore } from '../channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
 export interface UserSessionService<UserSession extends CoreUserSession> {
+    sessionChanged: boolean;
     setInitial(session: UserSession): void;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
@@ -9,6 +10,7 @@ export interface UserSessionService<UserSession extends CoreUserSession> {
 export declare class PikkuUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
     private channelStore?;
     private channelId?;
+    sessionChanged: boolean;
     private session;
     constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
     setInitial(session: UserSession): void;

package/dist/services/user-session-service.js

@@ -1,6 +1,7 @@
 export class PikkuUserSessionService {
     channelStore;
     channelId;
+    sessionChanged = false;
     session;
     constructor(channelStore, channelId) {
         this.channelStore = channelStore;
@@ -13,10 +14,12 @@ export class PikkuUserSessionService {
         this.session = session;
     }
     set(session) {
+        this.sessionChanged = true;
         this.session = session;
         return this.channelStore?.setUserSession(this.channelId, session);
     }
     clear() {
+        this.sessionChanged = true;
         this.session = undefined;
         return this.channelStore?.setUserSession(this.channelId, null);
     }

package/dist/time-utils.d.ts

@@ -0,0 +1,12 @@
+type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'year';
+export interface RelativeTimeInput {
+    value: number;
+    unit: TimeUnit;
+}
+export declare const getRelativeTimeOffset: ({ value, unit, }: RelativeTimeInput) => number;
+/**
+ * Returns a Unix timestamp (in seconds) offset from now by the given duration.
+ * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
+ */
+export declare const getRelativeTimeOffsetFromNow: (relativeTime: RelativeTimeInput) => Date;
+export {};