@pikku/core 0.6.23 → 0.6.25

package/src/http/pikku-fetch-http-response.test.ts

@@ -0,0 +1,82 @@
+import { describe, test } from 'node:test'
+import assert from 'assert'
+import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js' // Adjust path if needed
+
+describe('PikkuFetchHTTPResponse', () => {
+  test('sets status code', () => {
+    const res = new PikkuFetchHTTPResponse().status(404).toResponse()
+    assert.strictEqual(res.status, 404)
+  })
+
+  test('sets headers', async () => {
+    const res = new PikkuFetchHTTPResponse()
+      .header('X-Test', 'value')
+      .header('X-Multi', ['a', 'b'])
+      .toResponse()
+
+    assert.strictEqual(res.headers.get('X-Test'), 'value')
+    const multi = res.headers.get('X-Multi')?.split(', ')
+    assert.deepEqual(multi, ['a', 'b'])
+  })
+
+  test('sets cookies', () => {
+    const res = new PikkuFetchHTTPResponse()
+      .cookie('token', 'abc123', { httpOnly: true, path: '/' })
+      .cookie('other', 'val', { maxAge: 3600 })
+      .toResponse()
+
+    const setCookieHeader = res.headers.get('Set-Cookie')
+    assert.ok(setCookieHeader)
+
+    const cookies = setCookieHeader!.split(', ')
+    assert.ok(cookies.some((c) => c.startsWith('token=abc123')))
+    assert.ok(cookies.some((c) => c.startsWith('other=val')))
+  })
+
+  test('json sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse()
+      .json({ hello: 'world' })
+      .toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'application/json')
+    const body = await res.json()
+    assert.deepEqual(body, { hello: 'world' })
+  })
+
+  test('text sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse().text('hello').toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'text/plain')
+    const text = await res.text()
+    assert.strictEqual(text, 'hello')
+  })
+
+  test('html sets correct content type and body', async () => {
+    const res = new PikkuFetchHTTPResponse().html('<p>hi</p>').toResponse()
+
+    assert.strictEqual(res.headers.get('Content-Type'), 'text/html')
+    const text = await res.text()
+    assert.strictEqual(text, '<p>hi</p>')
+  })
+
+  test('arrayBuffer sets correct content type', async () => {
+    const buffer = new Uint8Array([1, 2, 3]).buffer
+    const res = new PikkuFetchHTTPResponse().arrayBuffer(buffer).toResponse()
+
+    assert.strictEqual(
+      res.headers.get('Content-Type'),
+      'application/octet-stream'
+    )
+    const body = await res.arrayBuffer()
+    assert.deepEqual(new Uint8Array(body), new Uint8Array([1, 2, 3]))
+  })
+
+  test('redirect sets Location header and status', () => {
+    const res = new PikkuFetchHTTPResponse()
+      .redirect('/login', 301)
+      .toResponse()
+
+    assert.strictEqual(res.status, 301)
+    assert.strictEqual(res.headers.get('Location'), '/login')
+  })
+})

package/src/http/pikku-fetch-http-response.ts

@@ -1,8 +1,14 @@
 import { PikkuHTTPResponse } from './http-routes.types.js'
+import {
+  SerializeOptions as CookieSerializeOptions,
+  serialize as serializeCookie,
+} from 'cookie'
 
 export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
   #statusCode: number = 200
   #headers = new Headers()
+  #cookies = new Map<string, { value: string; flags: CookieSerializeOptions }>()
+
   #body: BodyInit | null = null
 
   public status(code: number): this {
@@ -10,8 +16,12 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     return this
   }
 
-  public cookie(name: string, value: string, flags: any): this {
-    // TODO
+  public cookie(
+    name: string,
+    value: string,
+    flags: CookieSerializeOptions
+  ): this {
+    this.#cookies.set(name, { value, flags })
     return this
   }
 
@@ -61,6 +71,10 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
   }
 
   public toResponse(args?: Record<string, any>): Response {
+    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/src/index.ts

@@ -11,7 +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/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/schema.test.ts

@@ -1,6 +1,6 @@
 import { test, describe, before } from 'node:test'
 import * as assert from 'assert'
-import { addSchema, coerceQueryStringToArray } from './schema.js'
+import { addSchema, coerceTopLevelDataFromSchema } from './schema.js'
 
 describe('Schema', () => {
   describe('coerceQueryStringToArray', () => {
@@ -24,32 +24,32 @@ describe('Schema', () => {
 
     test('should split a string into an array for properties of type array', () => {
       const data = { tags: 'a,b,c' }
-      coerceQueryStringToArray('testSchema', data)
+      coerceTopLevelDataFromSchema('testSchema', data)
       assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
     })
 
     test('should not modify properties of type array if they are already arrays', () => {
       const data = { tags: ['a', 'b', 'c'] }
-      coerceQueryStringToArray('testSchema', data)
+      coerceTopLevelDataFromSchema('testSchema', data)
       assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
     })
 
     test('should not modify properties that are not type array', () => {
       const data = { count: 5, name: 'example' }
-      coerceQueryStringToArray('testSchema', data)
+      coerceTopLevelDataFromSchema('testSchema', data)
       assert.strictEqual(data.count, 5)
       assert.strictEqual(data.name, 'example')
     })
 
     test('should handle cases where the data object does not have a key present in the schema', () => {
       const data = { unknownKey: 'shouldRemain' }
-      coerceQueryStringToArray('testSchema', data)
+      coerceTopLevelDataFromSchema('testSchema', data)
       assert.strictEqual(data.unknownKey, 'shouldRemain')
     })
 
     test('should handle cases where schema properties contain boolean values', () => {
       const data = { tags: 'a,b,c', isActive: 'true' }
-      coerceQueryStringToArray('booleanSchema', data)
+      coerceTopLevelDataFromSchema('booleanSchema', data)
       assert.deepStrictEqual(data.tags, ['a', 'b', 'c'])
       assert.strictEqual(data.isActive, 'true') // No coercion should happen
     })

package/src/schema.ts

@@ -58,7 +58,7 @@ const validateAllSchemasLoaded = (
   }
 }
 
-export const coerceQueryStringToArray = (schemaName: string, data: any) => {
+export const coerceTopLevelDataFromSchema = (schemaName: string, data: any) => {
   const schema = pikkuState('misc', 'schemas').get(schemaName)
   for (const key in schema.properties) {
     const property = schema.properties[key]
@@ -71,6 +71,8 @@ export const coerceQueryStringToArray = (schemaName: string, data: any) => {
     }
     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])
     }
   }
 }

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>
 
 /**