@pikku/core 0.6.13 → 0.6.15

package/src/channel/serverless/serverless-channel-runner.ts

@@ -1,4 +1,4 @@
-import { CoreUserSession, SessionServices } from '../../types/core.types.js'
+import { SessionServices } from '../../types/core.types.js'
 import { closeSessionServices } from '../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import { getChannels, openChannel } from '../channel-runner.js'
@@ -8,11 +8,11 @@ import type {
   RunChannelParams,
   PikkuChannelHandlerFactory,
 } from '../channel.types.js'
-import {
-  createHTTPInteraction,
-  handleError,
-} from '../../http/http-route-runner.js'
+import { createHTTPInteraction } from '../../http/http-route-runner.js'
 import { ChannelStore } from '../channel-store.js'
+import { handleError } from '../../handle-error.js'
+import { RemoteUserSessionService } from '../../services/user-session-service.js'
+import { runMiddleware } from '../../middleware-runner.js'
 
 export interface RunServerlessChannelParams<ChannelData>
   extends RunChannelParams<ChannelData> {
@@ -23,14 +23,12 @@ export interface RunServerlessChannelParams<ChannelData>
 
 const getVariablesForChannel = ({
   channelId,
-  userSession,
   channelName,
   channelHandlerFactory,
   openingData,
 }: {
   channelId: string
   channelName: string
-  userSession?: CoreUserSession
   channelHandlerFactory: PikkuChannelHandlerFactory
   openingData?: unknown
 }) => {
@@ -44,8 +42,7 @@ const getVariablesForChannel = ({
   const channelHandler = channelHandlerFactory(
     channelId,
     channelConfig.name,
-    openingData,
-    userSession
+    openingData
   )
   return {
     channelConfig,
@@ -73,54 +70,71 @@ export const runChannelConnect = async ({
   RunServerlessChannelParams<unknown>) => {
   let sessionServices: SessionServices | undefined
   const http = createHTTPInteraction(request, response)
-  try {
-    const { userSession, channelConfig, openingData } = await openChannel({
-      channelId,
-      createSessionServices,
-      http,
-      route,
-      singletonServices,
-      coerceToArray,
-    })
-    await channelStore.addChannel({
-      channelId,
-      channelName: channelConfig.name,
-      openingData,
-      channelObject,
-    })
-    const { channel } = getVariablesForChannel({
-      channelId,
-      userSession,
-      channelHandlerFactory,
-      channelName: channelConfig.name,
-    })
-    if (createSessionServices) {
-      sessionServices = await createSessionServices(
-        singletonServices,
-        { http },
-        userSession
+  const userSessionService = new RemoteUserSessionService(
+    channelStore,
+    channelId
+  )
+
+  const { channelConfig, openingData } = await openChannel({
+    channelId,
+    createSessionServices,
+    http,
+    route,
+    singletonServices,
+    coerceToArray,
+  })
+
+  const main = async () => {
+    try {
+      await channelStore.addChannel({
+        channelId,
+        channelName: channelConfig.name,
+        openingData,
+        channelObject,
+      })
+      const { channel } = getVariablesForChannel({
+        channelId,
+        channelHandlerFactory,
+        channelName: channelConfig.name,
+      })
+      if (createSessionServices) {
+        sessionServices = await createSessionServices(
+          singletonServices,
+          { http },
+          await userSessionService.get()
+        )
+      }
+      await channelConfig.onConnect?.(
+        { ...singletonServices, ...sessionServices },
+        channel
       )
-    }
-    await channelConfig.onConnect?.(
-      { ...singletonServices, ...sessionServices },
-      channel
-    )
-    http?.response?.setStatus(101)
-  } catch (e: any) {
-    handleError(
-      e,
-      http,
-      channelId,
-      singletonServices.logger,
-      logWarningsForStatusCodes,
-      respondWith404,
-      bubbleErrors
-    )
-  } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
+      http?.response?.setStatus(101)
+    } catch (e: any) {
+      handleError(
+        e,
+        http,
+        channelId,
+        singletonServices.logger,
+        logWarningsForStatusCodes,
+        respondWith404,
+        bubbleErrors
+      )
+    } finally {
+      if (sessionServices) {
+        await closeSessionServices(singletonServices.logger, sessionServices)
+      }
     }
   }
+
+  await runMiddleware(
+    {
+      ...singletonServices,
+      userSessionService,
+    },
+    { http },
+    channelConfig.middleware || [],
+    main
+  )
 }
 
 export const runChannelDisconnect = async ({
@@ -132,7 +146,6 @@ export const runChannelDisconnect = async ({
     await params.channelStore.getChannel(params.channelId)
   const { channel, channelConfig } = getVariablesForChannel({
     ...params,
-    userSession,
     openingData,
     channelName,
   })
@@ -162,7 +175,6 @@ export const runChannelMessage = async (
     await params.channelStore.getChannel(params.channelId)
   const { channelHandler, channelConfig } = getVariablesForChannel({
     ...params,
-    userSession,
     openingData,
     channelName,
   })

package/src/handle-error.ts

@@ -0,0 +1,67 @@
+import { getErrorResponse } from './errors/error-handler.js'
+import { NotFoundError } from './errors/errors.js'
+import { Logger } from './services/logger.js'
+import { PikkuHTTP } from './http/http-routes.types.js'
+
+/**
+ * Handle errors that occur during route processing
+ *
+ * @param {any} e - The error that occurred
+ * @param {PikkuHTTP | undefined} http - HTTP interaction object
+ * @param {string} trackerId - Unique ID for tracking this error
+ * @param {Logger} logger - Logger service
+ * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings
+ * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
+ * @param {boolean} bubbleError - Whether to throw the error after handling
+ */
+export const handleError = (
+  e: any,
+  http: PikkuHTTP | undefined,
+  trackerId: string,
+  logger: Logger,
+  logWarningsForStatusCodes: number[],
+  respondWith404: boolean,
+  bubbleError: boolean
+) => {
+  // Skip 404 handling if configured to do so
+  if (e instanceof NotFoundError && !respondWith404) {
+    return
+  }
+
+  // Get appropriate error response
+  const errorResponse = getErrorResponse(e)
+
+  if (errorResponse != null) {
+    // Set status and response body
+    http?.response?.setStatus(errorResponse.status)
+    http?.response?.setJson({
+      message: errorResponse.message,
+      payload: (e as any).payload,
+      traceId: trackerId,
+    })
+
+    // Log certain status codes as warnings
+    if (logWarningsForStatusCodes.includes(errorResponse.status)) {
+      logger.warn(`Warning id: ${trackerId}`)
+      logger.warn(e)
+    }
+  } else {
+    // Handle unexpected errors
+    logger.warn(`Error id: ${trackerId}`)
+    logger.error(e)
+    http?.response?.setStatus(500)
+    http?.response?.setJson({ errorId: trackerId })
+  }
+
+  // Handle 404 errors specifically
+  if (e instanceof NotFoundError) {
+    http?.response?.end()
+  }
+
+  // Either bubble up or end the response
+  if (bubbleError) {
+    throw e
+  } else {
+    http?.response?.end()
+  }
+}

package/src/http/http-route-runner.test.ts

@@ -1,15 +1,10 @@
 import { test, describe, beforeEach, afterEach } from 'node:test'
 import * as assert from 'assert'
-import { NotFoundError, NotImplementedError } from '../errors/errors.js'
+import { NotFoundError } from '../errors/errors.js'
 import { PikkuHTTPAbstractRequest } from './pikku-http-abstract-request.js'
 import { PikkuHTTPAbstractResponse } from './pikku-http-abstract-response.js'
-import { JSONValue } from '../types/core.types.js'
-import {
-  getUserSession,
-  runHTTPRoute,
-  clearRoutes,
-  addRoute,
-} from './http-route-runner.js'
+import { JSONValue, PikkuMiddleware } from '../types/core.types.js'
+import { runHTTPRoute, clearRoutes, addRoute } from './http-route-runner.js'
 
 class PikkuTestRequest extends PikkuHTTPAbstractRequest {
   public getBody(): Promise<unknown> {
@@ -32,6 +27,11 @@ class PikkuTestResponse extends PikkuHTTPAbstractResponse {
   }
 }
 
+const sessionMiddleware: PikkuMiddleware = async (services, _, next) => {
+  services.userSessionService.set({ userId: 'test' } as any)
+  await next()
+}
+
 describe('runHTTPRoute', () => {
   let singletonServices: any
   let createSessionServices: any
@@ -47,13 +47,10 @@ describe('runHTTPRoute', () => {
         warn: () => {},
         error: () => {},
       },
-      httpSessionService: {
-        getUserSession: async () => {},
-      },
     }
 
     createSessionServices = async () => ({})
-    request = new PikkuTestRequest()
+    request = new PikkuTestRequest('path', 'get')
     response = new PikkuTestResponse()
 
     request.getData = async () => ({})
@@ -91,6 +88,7 @@ describe('runHTTPRoute', () => {
       route: 'test',
       method: 'get',
       func: routeFunc,
+      middleware: [sessionMiddleware],
     })
 
     const result = await runHTTPRoute({
@@ -116,6 +114,7 @@ describe('runHTTPRoute', () => {
       method: 'get',
       func: routeFunc,
       permissions,
+      middleware: [sessionMiddleware],
     })
 
     await runHTTPRoute({
@@ -141,6 +140,7 @@ describe('runHTTPRoute', () => {
       route: 'test',
       method: 'get',
       func: routeFunc,
+      middleware: [sessionMiddleware],
     })
 
     await assert.rejects(
@@ -158,36 +158,3 @@ describe('runHTTPRoute', () => {
     )
   })
 })
-
-describe('getUserSession', () => {
-  let sessionService: any
-  let request: any
-
-  beforeEach(() => {
-    sessionService = {
-      getUserSession: async () => ({}),
-    }
-    request = new PikkuTestRequest()
-  })
-
-  test('should return user session when sessionService is provided', async () => {
-    const userSession = { id: '123', username: 'test' }
-    sessionService.getUserSession = async () => userSession
-
-    const result = await getUserSession(sessionService, true, request)
-
-    assert.deepStrictEqual(result, userSession)
-  })
-
-  test('should throw NotImplementedError when session is required but sessionService is not provided', async () => {
-    await assert.rejects(
-      async () => getUserSession(undefined, true, request),
-      NotImplementedError
-    )
-  })
-
-  test('should return undefined when session is not required and sessionService is not provided', async () => {
-    const result = await getUserSession(undefined, false, request)
-    assert.strictEqual(result, undefined)
-  })
-})