@pikku/core 0.6.23 → 0.6.24

package/src/middleware/auth-apikey.ts

@@ -33,7 +33,7 @@ export const authAPIKey = <
     }
 )) => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSessionService.get()) {
+    if (!http?.request || services.userSession.get()) {
       return next()
     }
 
@@ -55,7 +55,7 @@ export const authAPIKey = <
         userSession = await getSessionForAPIKey!(services as any, apiKey)
       }
       if (userSession) {
-        services.userSessionService.setInitial(userSession)
+        services.userSession.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-bearer.ts

@@ -29,7 +29,7 @@ export const authBearer = <
 } = {}): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
     // Skip if session already exists.
-    if (!http?.request || services.userSessionService.get()) {
+    if (!http?.request || services.userSession.get()) {
       return next()
     }
 
@@ -56,7 +56,7 @@ export const authBearer = <
       }
 
       if (userSession) {
-        services.userSessionService.setInitial(userSession)
+        services.userSession.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-cookie.ts

@@ -1,25 +1,34 @@
+import { SerializeOptions } from 'cookie'
 import {
   CoreConfig,
   CoreSingletonServices,
   CoreUserSession,
   PikkuMiddleware,
 } from '../types/core.types.js'
+import {
+  getRelativeTimeOffsetFromNow,
+  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 const authCookie = <
   SingletonServices extends CoreSingletonServices<CoreConfig>,
   UserSession extends CoreUserSession,
 >({
-  cookieNames,
+  name,
   getSessionForCookieValue,
   jwt,
+  options,
+  expiresIn,
 }: {
-  cookieNames: string[]
+  name: string
+  options: SerializeOptions
+  expiresIn: RelativeTimeInput
 } & (
   | {
       getSessionForCookieValue: (
@@ -35,34 +44,55 @@ export const authCookie = <
     }
 )): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSessionService.get()) {
+    if (!http?.request || services.userSession.get()) {
       return next()
     }
 
     let userSession: UserSession | null = 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)
-        } else if (getSessionForCookieValue) {
-          userSession = await getSessionForCookieValue(
-            services as any,
-            cookieValue,
-            cookieName
-          )
+    const cookieValue = http.request.cookie(name)
+    if (cookieValue) {
+      if (jwt) {
+        if (!services.jwt) {
+          throw new Error('JWT service is required for JWT decoding.')
         }
-        break
+        userSession = await services.jwt.decode(cookieValue)
+      } else if (getSessionForCookieValue) {
+        userSession = await getSessionForCookieValue(
+          services as any,
+          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/src/middleware-runner.ts

@@ -8,7 +8,7 @@ import {
 /**
  * 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.
@@ -16,7 +16,7 @@ import {
  *
  * @example
  * runMiddleware(
- *   { ...services, userSessionService },
+ *   { ...services, userSession },
  *   { http },
  *   [middleware1, middleware2, middleware3],
  *   async () => { return await runMain(); }
@@ -24,7 +24,7 @@ import {
  */
 export const runMiddleware = async (
   services: CoreSingletonServices & {
-    userSessionService: UserSessionService<any>
+    userSession: UserSessionService<any>
   },
   interaction: PikkuInteraction,
   middlewares: PikkuMiddleware[],

package/src/services/jwt-service.ts

@@ -1,3 +1,5 @@
+import { RelativeTimeInput } from '../time-utils.js'
+
 /**
  * Interface for handling JSON Web Tokens (JWT).
  */
@@ -8,7 +10,10 @@ 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.

package/src/services/local-secrets.ts

@@ -10,7 +10,7 @@ export class LocalSecretService implements SecretService {
    * Creates an instance of LocalSecretService.
    */
   constructor(
-    private variablesService: VariablesService = new LocalVariablesService()
+    private variables: VariablesService = new LocalVariablesService()
   ) {}
 
   /**
@@ -20,7 +20,7 @@ export class LocalSecretService implements SecretService {
    * @throws {Error} If the secret is not found.
    */
   public async getSecretJSON<R>(key: string): Promise<R> {
-    const value = await this.variablesService.get(key)
+    const value = await this.variables.get(key)
     if (value) {
       return JSON.parse(value)
     }
@@ -34,7 +34,7 @@ export class LocalSecretService implements SecretService {
    * @throws {Error} If the secret is not found.
    */
   public async getSecret(key: string): Promise<string> {
-    const value = await this.variablesService.get(key)
+    const value = await this.variables.get(key)
     if (value) {
       return value
     }

package/src/services/user-session-service.ts

@@ -2,6 +2,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
@@ -11,6 +12,7 @@ export interface UserSessionService<UserSession extends CoreUserSession> {
 export class PikkuUserSessionService<UserSession extends CoreUserSession>
   implements UserSessionService<UserSession>
 {
+  public sessionChanged = false
   private session: UserSession | undefined
   constructor(
     private channelStore?: ChannelStore<unknown, unknown, UserSession>,
@@ -26,11 +28,13 @@ export class PikkuUserSessionService<UserSession extends CoreUserSession>
   }
 
   public set(session: UserSession) {
+    this.sessionChanged = true
     this.session = session
     return this.channelStore?.setUserSession(this.channelId!, session)
   }
 
   public clear() {
+    this.sessionChanged = true
     this.session = undefined
     return this.channelStore?.setUserSession(this.channelId!, null)
   }

package/src/time-utils.test.ts

@@ -0,0 +1,56 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  getRelativeTimeOffset,
+  getRelativeTimeOffsetFromNow,
+  RelativeTimeInput,
+} from './time-utils'
+
+const approxEqual = (a: number, b: number, delta: number = 10): boolean =>
+  Math.abs(a - b) <= delta
+
+describe('Time Utils', () => {
+  const offsetCases: Array<{ input: RelativeTimeInput; expected: number }> = [
+    { input: { value: 1, unit: 'second' }, expected: 1000 },
+    { input: { value: 2, unit: 'minute' }, expected: 120000 },
+    { input: { value: 1.5, unit: 'hour' }, expected: 5400000 },
+    { input: { value: -1, unit: 'day' }, expected: -86400000 },
+    { input: { value: 1, unit: 'week' }, expected: 604800000 },
+    {
+      input: { value: 2, unit: 'year' },
+      expected: Math.round(2 * 365.25 * 86400 * 1000),
+    },
+  ]
+
+  describe('getRelativeTimeOffset', () => {
+    for (const { input, expected } of offsetCases) {
+      test(`returns ${expected} ms for ${input.value} ${input.unit}`, () => {
+        const actual = getRelativeTimeOffset(input)
+        assert.strictEqual(actual, expected)
+      })
+    }
+  })
+
+  describe('getRelativeTimeOffsetFromNow', () => {
+    test('returns a Date ~1 minute in the future', () => {
+      const now = Date.now()
+      const result = getRelativeTimeOffsetFromNow({ value: 1, unit: 'minute' })
+      const delta = result.getTime() - now
+      assert.ok(
+        approxEqual(delta, 60000),
+        `Expected ~60000ms ahead, got ${delta}ms`
+      )
+    })
+
+    test('returns a Date ~2 hours in the past', () => {
+      const now = Date.now()
+      const result = getRelativeTimeOffsetFromNow({ value: -2, unit: 'hour' })
+      const delta = now - result.getTime()
+      assert.ok(
+        approxEqual(delta, 7200000),
+        `Expected ~7200000ms ago, got ${delta}ms`
+      )
+    })
+  })
+})

package/src/time-utils.ts

@@ -0,0 +1,32 @@
+type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'year'
+
+export interface RelativeTimeInput {
+  value: number // negative = in the past
+  unit: TimeUnit
+}
+
+const multipliers: Record<TimeUnit, number> = {
+  second: 1,
+  minute: 60,
+  hour: 60 * 60,
+  day: 60 * 60 * 24,
+  week: 60 * 60 * 24 * 7,
+  year: Math.round(365.25 * 60 * 60 * 24),
+}
+
+export const getRelativeTimeOffset = ({
+  value,
+  unit,
+}: RelativeTimeInput): number => {
+  return Math.round(value * multipliers[unit]) * 1000 // convert to milliseconds
+}
+
+/**
+ * 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 const getRelativeTimeOffsetFromNow = (
+  relativeTime: RelativeTimeInput
+): Date => {
+  return new Date(Date.now() + getRelativeTimeOffset(relativeTime))
+}

package/src/types/core.types.ts

@@ -65,17 +65,17 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
   /** JWT Service */
   jwt?: JWTService
   /** The schema library used to validate data */
-  schemaService?: SchemaService
+  schema?: SchemaService
   /** The core configuration for the application. */
   config: Config
   /** The logger used by the application. */
   logger: Logger
   /** The variable service to be used */
-  variablesService: VariablesService
+  variables: VariablesService
   /** The subscription service that is passed to streams */
   eventHub?: EventHubService<unknown>
   /** SecretServce  */
-  secretService?: SecretService
+  secrets?: SecretService
 }
 
 /**
@@ -93,7 +93,7 @@ export type PikkuMiddleware<
   UserSession extends CoreUserSession = CoreUserSession,
 > = (
   services: SingletonServices & {
-    userSessionService: UserSessionService<UserSession>
+    userSession: UserSessionService<UserSession>
   },
   interactions: PikkuInteraction,
   next: () => Promise<void>
@@ -145,7 +145,7 @@ export type CreateSessionServices<
  * Defines a function type for creating config.
  */
 export type CreateConfig<Config extends CoreConfig> = (
-  variablesService?: VariablesService
+  variables?: VariablesService
 ) => Promise<Config>
 
 /**

package/src/types/functions.types.ts

@@ -46,7 +46,7 @@ export type CoreAPIFunctionSessionless<
 > = (
   services: Services,
   data: In,
-  session: Session
+  session?: Session
 ) => Channel extends true ? Promise<Out> | Promise<void> : Promise<Out>
 
 /**