@pikku/core 0.6.16 → 0.6.17

package/src/middleware/auth-apikey.ts

@@ -0,0 +1,65 @@
+import {
+  CoreConfig,
+  CoreSingletonServices,
+  CoreUserSession,
+  PikkuMiddleware,
+} from '../types/core.types.js'
+
+/**
+ * API key middleware that retrieves a session from the 'x-api-key' header using a provided callback.
+ *
+ * @param options.getSessionForAPIKey - A function that returns a session when provided an API key.
+ */
+export const authAPIKey = <
+  SingletonServices extends CoreSingletonServices<CoreConfig>,
+  UserSession extends CoreUserSession,
+>({
+  source,
+  getSessionForAPIKey,
+  jwt,
+}: {
+  source: 'header' | 'query' | 'all'
+} & (
+  | {
+      getSessionForAPIKey?: undefined
+      jwt?: true
+    }
+  | {
+      getSessionForAPIKey: (
+        services: SingletonServices,
+        apiKey: string
+      ) => Promise<any>
+      jwt?: false
+    }
+)) => {
+  const middleware: PikkuMiddleware = async (services, { http }, next) => {
+    if (!http?.request || services.userSession.get()) {
+      return next()
+    }
+
+    let apiKey: string | null = null
+    if (source === 'header' || source === 'all') {
+      apiKey = http.request.getHeader('x-api-key') as string | null
+    }
+    if (!apiKey && (source === 'query' || source === 'all')) {
+      apiKey = http.request.getQuery().apiKey as string | null
+    }
+    if (apiKey) {
+      let userSession: UserSession | null = null
+      if (jwt) {
+        if (!services.jwt) {
+          throw new Error('JWT service is required for JWT decoding.')
+        }
+        userSession = await services.jwt.decode(apiKey)
+      } else {
+        userSession = await getSessionForAPIKey!(services as any, apiKey)
+      }
+      if (userSession) {
+        await services.userSession.set(userSession)
+      }
+    }
+    return next()
+  }
+
+  return middleware
+}

package/src/middleware/auth-bearer.ts

@@ -0,0 +1,65 @@
+import { InvalidSessionError } from '../errors/errors.js'
+import {
+  CoreConfig,
+  CoreSingletonServices,
+  CoreUserSession,
+  PikkuMiddleware,
+} from '../types/core.types.js'
+
+/**
+ * Extracts the Bearer token from the Authorization header
+ */
+export const authBearer = <
+  SingletonServices extends CoreSingletonServices<CoreConfig>,
+  UserSession extends CoreUserSession,
+>({
+  token,
+  jwt,
+  getSession,
+}: {
+  token?: {
+    value: string
+    userSession: UserSession
+  }
+  jwt?: boolean
+  getSession?: (
+    services: SingletonServices,
+    token: string
+  ) => Promise<UserSession> | UserSession
+} = {}): PikkuMiddleware => {
+  const middleware: PikkuMiddleware = async (services, { http }, next) => {
+    // Skip if session already exists.
+    if (!http?.request || services.userSession.get()) {
+      return next()
+    }
+
+    const authHeader =
+      http.request.getHeader('authorization') ||
+      http.request.getHeader('Authorization')
+    if (authHeader) {
+      const [scheme, bearerToken] = authHeader.split(' ')
+      if (scheme !== 'Bearer' || !token || !bearerToken) {
+        throw new InvalidSessionError()
+      }
+      let userSession: UserSession | null = null
+      if (jwt) {
+        if (!services.jwt) {
+          throw new Error('JWT service is required for JWT decoding.')
+        }
+        userSession = await services.jwt.decode(bearerToken)
+      } else if (token) {
+        if (bearerToken === token.value) {
+          userSession = token.userSession
+        }
+      } else if (getSession) {
+        userSession = await getSession(services as any, token)
+      }
+
+      if (userSession) {
+        await services.userSession.set(userSession)
+      }
+    }
+    return next()
+  }
+  return middleware
+}

package/src/middleware/auth-cookie.ts

@@ -0,0 +1,76 @@
+import {
+  CoreConfig,
+  CoreSingletonServices,
+  CoreUserSession,
+  PikkuMiddleware,
+} from '../types/core.types.js'
+
+/**
+ * Cookie middleware that extracts a session from cookies.
+ *
+ * @param options.cookieNames - 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,
+  getSessionForCookieValue,
+  jwt,
+}: {
+  cookieNames: string[]
+} & (
+  | {
+      getSessionForCookieValue: (
+        services: SingletonServices,
+        cookieValue: string,
+        cookieName: string
+      ) => Promise<UserSession>
+      jwt?: false
+    }
+  | {
+      getSessionForCookieValue?: undefined
+      jwt: true
+    }
+)): PikkuMiddleware => {
+  const middleware: PikkuMiddleware = async (services, { http }, next) => {
+    if (!http?.request || services.userSession.get()) {
+      return next()
+    }
+
+    const cookies = http.request.getCookies()
+    if (cookies) {
+      let cookieName: string | undefined
+      for (const name of cookieNames) {
+        if (cookies[name]) {
+          cookieName = name
+          break
+        }
+      }
+      if (cookieName) {
+        let userSession: UserSession | null = null
+        const cookieValue = cookies[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
+            )
+          }
+          if (userSession) {
+            await services.userSession.set(userSession)
+          }
+        }
+      }
+    }
+    return next()
+  }
+  return middleware
+}

package/src/middleware/index.ts

@@ -1,4 +1,3 @@
-export * from './auth-api-key.js'
-export * from './auth-cookie-middleware.js'
-export * from './auth-jwt-middleware.js'
-export * from './auth-query-middleware.js'
+export * from './auth-apikey.js'
+export * from './auth-cookie.js'
+export * from './auth-bearer.js'

package/src/middleware/timeout.ts

@@ -0,0 +1,13 @@
+import { RequestTimeoutError } from '../errors/errors.js'
+import { PikkuMiddleware } from '../types/core.types.js'
+
+export const timeout = (timeout: number) => {
+  const middleware: PikkuMiddleware = async (_services, _interaction, next) => {
+    setTimeout(() => {
+      throw new RequestTimeoutError()
+    }, timeout)
+
+    await next()
+  }
+  return middleware
+}

package/src/middleware-runner.ts

@@ -24,7 +24,7 @@ import {
  */
 export const runMiddleware = async (
   services: CoreSingletonServices & {
-    userSessionService: UserSessionService<any>
+    userSession: UserSessionService<any>
   },
   interaction: PikkuInteraction,
   middlewares: PikkuMiddleware[],

package/src/pikku-state.ts

@@ -0,0 +1,70 @@
+import { ChannelsMeta, CoreAPIChannels } from './channel/channel.types.js'
+import {
+  CoreHTTPFunctionRoutes,
+  HTTPRoutesMeta,
+} from './http/http-routes.types.js'
+import { PikkuMiddleware } from './types/core.types.js'
+import {
+  CoreScheduledTask,
+  ScheduledTasksMeta,
+} from './scheduler/scheduler.types.js'
+import { ErrorDetails, PikkuError } from './errors/error-handler.js'
+
+interface PikkuState {
+  http: {
+    middleware: Array<{ route: string; middleware: PikkuMiddleware[] }>
+    routes: CoreHTTPFunctionRoutes
+    meta: HTTPRoutesMeta
+  }
+  channel: {
+    channels: CoreAPIChannels
+    meta: ChannelsMeta
+  }
+  scheduler: {
+    tasks: Map<string, CoreScheduledTask>
+    meta: ScheduledTasksMeta
+  }
+  errors: {
+    errors: Map<PikkuError, ErrorDetails>
+  }
+}
+
+export const resetPikkuState = () => {
+  globalThis.pikkuState = {
+    http: {
+      middleware: [],
+      routes: [],
+      meta: [],
+    },
+    channel: {
+      channels: [],
+      meta: [],
+    },
+    scheduler: {
+      tasks: new Map(),
+      meta: [],
+    },
+    errors: {
+      // We keep errors since they are registered globally
+      errors: globalThis.pikkuState?.errors?.errors || new Map(),
+    },
+  }
+}
+
+if (!globalThis.pikkuState) {
+  resetPikkuState()
+}
+
+export const pikkuState = <
+  Type extends keyof PikkuState,
+  Content extends keyof PikkuState[Type],
+>(
+  type: Type,
+  content: Content,
+  value?: PikkuState[Type][Content]
+): PikkuState[Type][Content] => {
+  if (value) {
+    globalThis.pikkuState[type][content] = value
+  }
+  return globalThis.pikkuState[type][content]
+}

package/src/scheduler/index.ts

@@ -1,11 +1,5 @@
 export * from './scheduler.types.js'
 
-export {
-  runScheduledTask,
-  getScheduledTasks,
-  addScheduledTask,
-  clearScheduledTasks,
-  setScheduledTasksMeta,
-} from './scheduler-runner.js'
+export { runScheduledTask, addScheduledTask } from './scheduler-runner.js'
 
 export * from './log-schedulers.js'

package/src/scheduler/log-schedulers.ts

@@ -1,12 +1,12 @@
+import { pikkuState } from '../pikku-state.js'
 import { Logger } from '../services/index.js'
-import { getScheduledTasks } from './scheduler-runner.js'
 
 /**
  * Logs all the loaded scheduled tasks.
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger: Logger) => {
-  const { scheduledTasks } = getScheduledTasks()
+  const scheduledTasks = pikkuState('scheduler', 'tasks')
   if (scheduledTasks.size === 0) {
     logger.info('No scheduled tasks added')
     return

package/src/scheduler/scheduler-runner.ts

@@ -4,14 +4,12 @@ import type {
   CoreUserSession,
   CreateSessionServices,
 } from '../types/core.types.js'
-import type {
-  CoreScheduledTask,
-  ScheduledTasksMeta,
-} from './scheduler.types.js'
+import type { CoreScheduledTask } from './scheduler.types.js'
 import type { CoreAPIFunctionSessionless } from '../types/functions.types.js'
 import crypto from 'crypto'
 import { getErrorResponse } from '../errors/error-handler.js'
 import { closeSessionServices } from '../utils.js'
+import { pikkuState } from '../pikku-state.js'
 
 export type RunScheduledTasksParams = {
   name: string
@@ -24,53 +22,16 @@ export type RunScheduledTasksParams = {
   >
 }
 
-if (!global.pikku?.scheduledTasks) {
-  global.pikku = global.pikku || {}
-  global.pikku.scheduledTasks = new Map<string, CoreScheduledTask>()
-  global.pikku.scheduledTasksMeta = []
-}
-
-const scheduledTasks = (): Map<string, CoreScheduledTask> => {
-  return global.pikku.scheduledTasks
-}
-
-const scheduledTasksMeta = (data?: ScheduledTasksMeta) => {
-  if (data) {
-    global.pikku.scheduledTasksMeta = data
-  }
-  return global.pikku.scheduledTasksMeta
-}
-
 export const addScheduledTask = <
   APIFunction extends CoreAPIFunctionSessionless<void, void>,
 >(
   scheduledTask: CoreScheduledTask<APIFunction>
 ) => {
-  if (scheduledTasks().has(scheduledTask.name)) {
+  const tasks = pikkuState('scheduler', 'tasks')
+  if (tasks.has(scheduledTask.name)) {
     throw new Error(`Scheduled task already exists: ${scheduledTask.name}`)
   }
-  scheduledTasks().set(scheduledTask.name, scheduledTask)
-}
-
-export const clearScheduledTasks = () => {
-  scheduledTasks().clear()
-}
-
-export const setScheduledTasksMeta = (
-  _scheduledTasksMeta: ScheduledTasksMeta
-) => {
-  scheduledTasksMeta(_scheduledTasksMeta)
-}
-
-/**
- * Returns all the cron jobs
- * @internal
- */
-export const getScheduledTasks = () => {
-  return {
-    scheduledTasks: scheduledTasks(),
-    scheduledTasksMeta: scheduledTasksMeta(),
-  }
+  tasks.set(scheduledTask.name, scheduledTask)
 }
 
 class ScheduledTaskNotFoundError extends Error {
@@ -94,7 +55,7 @@ export async function runScheduledTask<
   const trackerId: string = crypto.randomUUID().toString()
 
   try {
-    const task = scheduledTasks().get(name)
+    const task = pikkuState('scheduler', 'tasks').get(name)
 
     if (!task) {
       throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`)

package/src/schema.ts

@@ -1,7 +1,7 @@
 import { Logger } from './services/logger.js'
-import { getRoutes } from './http/http-route-runner.js'
 import { SchemaService } from './services/schema-service.js'
 import { UnprocessableContentError } from './errors/errors.js'
+import { pikkuState } from './pikku-state.js'
 
 /**
  * Retrieves the global schemas map.
@@ -58,7 +58,7 @@ const validateAllSchemasLoaded = (
   logger: Logger,
   schemaService: SchemaService
 ) => {
-  const { routesMeta } = getRoutes()
+  const routesMeta = pikkuState('http', 'meta')
   const validators = schemaService.getSchemaNames()
 
   const missingSchemas: string[] = []

package/src/services/jwt-service.ts

@@ -1,10 +1,7 @@
-import { CoreUserSession } from '../types/core.types.js'
-
 /**
  * Interface for handling JSON Web Tokens (JWT).
- * @template UserSession - The type of the user session.
  */
-export interface JWTService<UserSession = CoreUserSession> {
+export interface JWTService {
   /**
    * Encodes a payload into a JWT.
    * @param expiresIn - The expiration time of the token.
@@ -25,12 +22,4 @@ export interface JWTService<UserSession = CoreUserSession> {
     invalidHashError?: Error,
     debug?: boolean
   ) => Promise<T>
-
-  /**
-   * Decodes a user session from a JWT.
-   * @param jwtToken - The JWT representing the user session.
-   * @param debug - An optional flag for debugging.
-   * @returns A promise that resolves to the decoded user session.
-   */
-  decodeSession: (jwtToken: string, debug?: any) => Promise<UserSession>
 }

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

@@ -34,16 +34,18 @@ export class RemoteUserSessionService<UserSession extends CoreUserSession>
     public session: UserSession | undefined = undefined
   ) {}
 
-  public async set(session: UserSession) {
-    await this.channelStore.setUserSession(this.channelId, session)
+  public set(session: UserSession) {
+    return this.channelStore.setUserSession(this.channelId, session)
   }
 
-  public async clear() {
-    await this.channelStore.setUserSession(this.channelId, undefined)
+  public clear() {
+    return this.channelStore.setUserSession(this.channelId, null)
   }
 
   public async get(): Promise<UserSession | undefined> {
-    const channel = await this.channelStore.getChannel(this.channelId)
-    return channel.userSession
+    const { session } = await this.channelStore.getChannelAndSession(
+      this.channelId
+    )
+    return session
   }
 }

package/src/types/core.types.ts

@@ -61,12 +61,9 @@ export interface CoreUserSession {}
 /**
  * Interface for core singleton services provided by Pikku.
  */
-export interface CoreSingletonServices<
-  Config extends CoreConfig = CoreConfig,
-  UserSession extends CoreUserSession = CoreUserSession,
-> {
+export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
   /** JWT Service */
-  jwt?: JWTService<UserSession>
+  jwt?: JWTService
   /** The schema library used to validate data */
   schemaService?: SchemaService
   /** The core configuration for the application. */
@@ -96,7 +93,7 @@ export type PikkuMiddleware<
   UserSession extends CoreUserSession = CoreUserSession,
 > = (
   services: SingletonServices & {
-    userSessionService: UserSessionService<UserSession>
+    userSession: UserSessionService<UserSession>
   },
   interactions: PikkuInteraction,
   next: () => Promise<void>