@pikku/core 0.6.12 → 0.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -22,7 +22,6 @@
     "./channel/local": "./dist/channel/local/index.js",
     "./channel/serverless": "./dist/channel/serverless/index.js",
     "./http": "./dist/http/index.js",
-    "./http/pikku-http-session-service": "./dist/http/pikku-http-session-service.js",
     "./http/pikku-http-abstract-response": "./dist/http/pikku-http-abstract-response.js",
     "./http/pikku-http-abstract-request": "./dist/http/pikku-http-abstract-request.js",
     "./errors": "./dist/errors/index.js",

package/src/channel/channel-handler.ts

@@ -1,8 +1,8 @@
 import {
   CoreSingletonServices,
   CoreServices,
-  CoreUserSession,
   JSONValue,
+  CoreUserSession,
 } from '../types/core.types.js'
 import { CoreAPIChannel, PikkuChannelHandler } from './channel.types.js'
 import { verifyPermissions } from '../permissions.js'
@@ -35,7 +35,7 @@ const validateSchema = (
 
 const validateAuth = (
   requiresSession: boolean,
-  channelHandler: PikkuChannelHandler,
+  userSession: CoreUserSession | undefined,
   onMessage: any
 ) => {
   const auth =
@@ -45,7 +45,7 @@ const validateAuth = (
         ? requiresSession
         : onMessage.auth
 
-  if (auth && !channelHandler.getChannel().userSession) {
+  if (auth && !userSession) {
     return false
   }
   return true
@@ -53,18 +53,13 @@ const validateAuth = (
 
 const validatePermissions = async (
   services: CoreServices,
-  channelHandler: PikkuChannelHandler,
+  userSession: CoreUserSession | undefined,
   onMessage: any,
   data: unknown
 ) => {
   const permissions =
     typeof onMessage === 'function' ? {} : onMessage.permissions
-  return await verifyPermissions(
-    permissions,
-    services,
-    data,
-    channelHandler.getChannel().userSession
-  )
+  return await verifyPermissions(permissions, services, data, userSession)
 }
 
 const runFunction = async (
@@ -80,7 +75,7 @@ const runFunction = async (
 export const processMessageHandlers = (
   services: CoreServices,
   channelConfig: CoreAPIChannel<any, any>,
-  channelHandler: PikkuChannelHandler<CoreUserSession, unknown>
+  channelHandler: PikkuChannelHandler
 ) => {
   const logger = services.logger
   const requiresSession = channelConfig.auth !== false

package/src/channel/channel-runner.ts

@@ -1,7 +1,6 @@
 import { NotFoundError } from '../errors/errors.js'
-import { loadUserSession } from '../http/http-route-runner.js'
-import { validateAndCoerce } from '../schema.js'
-import { CoreUserSession } from '../types/core.types.js'
+import { coerceQueryStringToArray, validateSchema } from '../schema.js'
+import { UserSessionService } from '../services/user-session-service.js'
 import {
   CoreAPIChannel,
   ChannelsMeta,
@@ -95,13 +94,13 @@ export const getMatchingChannelConfig = (request: string) => {
 export const openChannel = async ({
   route,
   singletonServices,
-  skipUserSession = false,
   coerceToArray = false,
   http,
+  userSessionService,
 }: Pick<CoreAPIChannel<unknown, string>, 'route'> &
-  Omit<RunChannelParams<unknown>, 'response' | 'request'> &
-  RunChannelOptions): Promise<{
-  userSession?: CoreUserSession
+  Omit<RunChannelParams<unknown>, 'response' | 'request'> & {
+    userSessionService?: UserSessionService<any>
+  } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreAPIChannel<unknown, any>
 }> => {
@@ -111,7 +110,7 @@ export const openChannel = async ({
     throw new NotFoundError(`Channel not found: ${route}`)
   }
 
-  const { matchedPath, params, channelConfig, schemaName } = matchingChannel
+  const { params, channelConfig, schemaName } = matchingChannel
 
   const requiresSession = channelConfig.auth !== false
   http?.request?.setParams(params)
@@ -120,37 +119,19 @@ export const openChannel = async ({
     `Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`
   )
 
-  const userSession = await loadUserSession(
-    skipUserSession,
-    // We may require a session, but we don't actually need it
-    // on connect since channels can authenticate later given
-    // how websocket sessions work (cookie or queryParam based)
-    false,
-    http,
-    matchedPath,
-    channelConfig,
-    singletonServices.logger,
-    singletonServices.httpSessionService
-  )
-
-  if (singletonServices.enforceChannelAccess) {
-    await singletonServices.enforceChannelAccess(
-      matchingChannel.channelConfig,
-      userSession
-    )
-  }
-
   let openingData: any | undefined
   if (http?.request) {
     openingData = await http.request.getData()
-    validateAndCoerce(
+    if (coerceToArray && schemaName) {
+      coerceQueryStringToArray(schemaName, openingData)
+    }
+    validateSchema(
       singletonServices.logger,
       singletonServices.schemaService,
       schemaName,
-      openingData,
-      coerceToArray
+      openingData
     )
   }
 
-  return { userSession, openingData, channelConfig }
+  return { openingData, channelConfig }
 }

package/src/channel/channel.types.ts

@@ -9,8 +9,8 @@ import {
   APIDocs,
   CoreServices,
   CoreSingletonServices,
-  CoreUserSession,
   CreateSessionServices,
+  PikkuMiddleware,
 } from '../types/core.types.js'
 import { CoreAPIPermission } from '../types/functions.types.js'
 import { PikkuRequest } from '../pikku-request.js'
@@ -56,6 +56,7 @@ export interface ChannelMeta {
     >
   >
   docs?: APIDocs
+  tags?: string[]
 }
 
 export type ChannelsMeta = ChannelMeta[]
@@ -64,19 +65,17 @@ export type CoreChannelConnection<
   ChannelData,
   Out = unknown,
   Services extends CoreServices = CoreServices,
-  Session extends CoreUserSession = CoreUserSession,
 > = (
   services: Services,
-  channel: PikkuChannel<Session, ChannelData, Out>
+  channel: PikkuChannel<ChannelData, Out>
 ) => Promise<void>
 
 export type CoreChannelDisconnection<
   ChannelData,
   Services extends CoreServices = CoreServices,
-  Session extends CoreUserSession = CoreUserSession,
 > = (
   services: Services,
-  channel: PikkuChannel<Session, ChannelData, never>
+  channel: PikkuChannel<ChannelData, never>
 ) => Promise<void>
 
 /**
@@ -91,10 +90,9 @@ export type CoreChannelMessage<
   Out,
   ChannelData,
   Services extends CoreServices = CoreServices,
-  Session extends CoreUserSession = CoreUserSession,
 > = (
   services: Services,
-  channel: PikkuChannel<Session, ChannelData, Out>,
+  channel: PikkuChannel<ChannelData, Out>,
   data: In
 ) => Promise<void | Out>
 
@@ -137,6 +135,7 @@ export type CoreAPIChannel<
         }
     >
   >
+  middleware?: PikkuMiddleware[]
   permissions?: Record<string, APIPermission[] | APIPermission>
   auth?: boolean
   docs?: Partial<{
@@ -145,18 +144,14 @@ export type CoreAPIChannel<
     errors: Array<typeof PikkuError>
     tags: string[]
   }>
+  tags?: string[]
 }
 
 export type CoreAPIChannels = CoreAPIChannel<any, string>[]
 
-export interface PikkuChannel<UserSession, OpeningData, Out> {
+export interface PikkuChannel<OpeningData, Out> {
   // The channel identifier
   channelId: string
-  // The user session, if available
-  userSession?: UserSession
-  // Update the user session, useful if you deal with auth on the
-  // stream side
-  setUserSession: (userSession: UserSession) => Promise<void> | void
   // The data the channel was created with. This could be query parameters
   // or parameters in the url.
   openingData: OpeningData
@@ -168,34 +163,13 @@ export interface PikkuChannel<UserSession, OpeningData, Out> {
   state: 'initial' | 'open' | 'closed'
 }
 
-export interface PikkuChannelHandler<
-  UserSession extends CoreUserSession = CoreUserSession,
-  OpeningData = unknown,
-  Out = unknown,
-> {
-  setUserSession(session: UserSession): Promise<void> | void
+export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {
   send(message: Out, isBinary?: boolean): Promise<void> | void
-  getChannel(): PikkuChannel<UserSession, OpeningData, Out>
+  getChannel(): PikkuChannel<OpeningData, Out>
 }
 
-export type PikkuChannelHandlerFactory<
-  OpeningData = unknown,
-  UserSession extends CoreUserSession = CoreUserSession,
-  Out = unknown,
-> = (
+export type PikkuChannelHandlerFactory<OpeningData = unknown, Out = unknown> = (
   channelId: string,
   channelName: string,
-  openingData: OpeningData,
-  userSession: UserSession | undefined
-) => PikkuChannelHandler<UserSession, OpeningData, Out>
-
-/**
- * Enfore access to a channel.
- * @param route - The channel to verify access for.
- * @param session - The user session.
- * @returns A promise that resolves if access is granted.
- */
-export type enforceChannelAccess = (
-  channel: CoreAPIChannel<unknown, any>,
-  session?: CoreUserSession
-) => Promise<void> | void
+  openingData: OpeningData
+) => PikkuChannelHandler<OpeningData, Out>

package/src/channel/local/local-channel-handler.ts

@@ -1,11 +1,9 @@
-import { CoreUserSession } from '../../types/core.types.js'
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js'
 
 export class PikkuLocalChannelHandler<
-  UserSession extends CoreUserSession = CoreUserSession,
   OpeningData = unknown,
   Out = unknown,
-> extends PikkuAbstractChannelHandler<UserSession, OpeningData, Out> {
+> extends PikkuAbstractChannelHandler<OpeningData, Out> {
   private onMessageCallback?: (message: unknown) => void
   private openCallBack?: () => void
   private closeCallback?: () => void
@@ -49,8 +47,4 @@ export class PikkuLocalChannelHandler<
     }
     return this.sendCallback?.(message, isBinary)
   }
-
-  public setUserSession(userSession: UserSession): void {
-    this.getChannel().userSession = userSession
-  }
 }

package/src/channel/local/local-channel-runner.test.ts

@@ -19,9 +19,6 @@ const mockLogger = {
 
 const mockSingletonServices = {
   logger: mockLogger,
-  // Provide a mock channelPermissionService only when needed
-  // e.g., channelPermissionService: { verifyChannelAccess: async () => {} },
-  httpSessionService: {},
 } as any
 
 // Mock request and response objects
@@ -79,7 +76,7 @@ test('runChannel should return undefined and 404 if no matching channel is found
   const result = await runLocalChannel({
     singletonServices: mockSingletonServices,
     channelId: 'test-channel-id',
-    request: new MockRequest(),
+    request: new MockRequest('/non-existent-channel', 'get'),
     response: mockResponse,
     route: '/non-existent-channel',
     createSessionServices: mockCreateSessionServices,
@@ -113,7 +110,7 @@ test('runChannel should return a channel handler if channel matches and no auth
   const result = await runLocalChannel({
     singletonServices: singletonServicesWithPerm,
     channelId: 'test-channel-id',
-    request: new MockRequest(),
+    request: new MockRequest('/test-channel', 'get'),
     response: new MockResponse(),
     route: '/test-channel',
     createSessionServices: mockCreateSessionServices,

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

@@ -1,8 +1,5 @@
 import { openChannel } from '../channel-runner.js'
-import {
-  createHTTPInteraction,
-  handleError,
-} from '../../http/http-route-runner.js'
+import { createHTTPInteraction } from '../../http/http-route-runner.js'
 import { closeSessionServices } from '../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import {
@@ -12,6 +9,9 @@ import {
 } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
 import { SessionServices } from '../../types/core.types.js'
+import { handleError } from '../../handle-error.js'
+import { runMiddleware } from '../../middleware-runner.js'
+import { LocalUserSessionService } from '../../services/user-session-service.js'
 
 export const runLocalChannel = async ({
   singletonServices,
@@ -30,65 +30,83 @@ export const runLocalChannel = async ({
   RunChannelParams<unknown>): Promise<PikkuLocalChannelHandler | void> => {
   let sessionServices: SessionServices<typeof singletonServices> | undefined
 
+  let channelHandler: PikkuLocalChannelHandler | undefined
+  const userSessionService = new LocalUserSessionService()
   const http = createHTTPInteraction(request, response)
-  try {
-    const { userSession, openingData, channelConfig } = await openChannel({
-      channelId,
-      createSessionServices,
-      respondWith404,
-      http,
-      route,
-      singletonServices,
-      skipUserSession,
-      coerceToArray,
-    })
-
-    const channelHandler = new PikkuLocalChannelHandler(
-      channelId,
-      channelConfig.name,
-      userSession,
-      openingData
-    )
-    const channel = channelHandler.getChannel()
 
-    if (createSessionServices) {
-      sessionServices = await createSessionServices(
+  const main = async () => {
+    try {
+      const { openingData, channelConfig } = await openChannel({
+        channelId,
+        createSessionServices,
+        respondWith404,
+        http,
+        route,
         singletonServices,
-        { http },
-        userSession
+        skipUserSession,
+        coerceToArray,
+      })
+
+      channelHandler = new PikkuLocalChannelHandler(
+        channelId,
+        channelConfig.name,
+        openingData
       )
-    }
-    const allServices = { ...singletonServices, ...sessionServices }
+      const channel = channelHandler.getChannel()
+      const userSession = await userSessionService.get()
+      if (createSessionServices) {
+        sessionServices = await createSessionServices(
+          singletonServices,
+          { http },
+          userSession
+        )
+      }
+      const allServices = {
+        ...singletonServices,
+        ...sessionServices,
+        userSessionService,
+      }
+
+      channelHandler.registerOnOpen(() => {
+        channelConfig.onConnect?.(allServices, channel)
+      })
 
-    channelHandler.registerOnOpen(() => {
-      channelConfig.onConnect?.(allServices, channel)
-    })
+      channelHandler.registerOnClose(async () => {
+        channelConfig.onDisconnect?.(allServices, channel)
+        if (sessionServices) {
+          await closeSessionServices(singletonServices.logger, sessionServices)
+        }
+      })
 
-    channelHandler.registerOnClose(async () => {
-      channelConfig.onDisconnect?.(allServices, channel)
+      channelHandler.registerOnMessage(
+        processMessageHandlers(allServices, channelConfig, channelHandler)
+      )
+    } catch (e: any) {
+      handleError(
+        e,
+        http,
+        channelId,
+        singletonServices.logger,
+        logWarningsForStatusCodes,
+        respondWith404,
+        bubbleErrors
+      )
+    } finally {
       if (sessionServices) {
         await closeSessionServices(singletonServices.logger, sessionServices)
       }
-    })
-
-    channelHandler.registerOnMessage(
-      processMessageHandlers(allServices, channelConfig, channelHandler)
-    )
-
-    return channelHandler
-  } 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 },
+    route.middleware || [],
+    main
+  )
+
+  return channelHandler!
 }

package/src/channel/pikku-abstract-channel-handler.test.ts

@@ -1,18 +1,12 @@
 import { test, beforeEach } from 'node:test'
 import * as assert from 'node:assert/strict'
-import { CoreUserSession } from '../types/core.types.js'
 import { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js'
 
 // A concrete implementation of the abstract class for testing
 class TestChannelHandler extends PikkuAbstractChannelHandler<
-  CoreUserSession,
   { param: string },
   { msg: string }
 > {
-  public async setUserSession(session: CoreUserSession): Promise<void> {
-    this.userSession = session
-  }
-
   public async send(message: { msg: string }, isBinary = false): Promise<void> {
     // Mock send implementation
   }
@@ -21,12 +15,9 @@ class TestChannelHandler extends PikkuAbstractChannelHandler<
 let handler: TestChannelHandler
 
 beforeEach(() => {
-  handler = new TestChannelHandler(
-    'test-channel-id',
-    'channel-name',
-    undefined,
-    { param: 'testParam' }
-  )
+  handler = new TestChannelHandler('test-channel-id', 'channel-name', {
+    param: 'testParam',
+  })
 })
 
 test('getChannel should return a channel with initial state', () => {
@@ -38,22 +29,6 @@ test('getChannel should return a channel with initial state', () => {
     { param: 'testParam' },
     'Opening data should be accessible'
   )
-  assert.equal(
-    channel.userSession,
-    undefined,
-    'Session should initially be undefined'
-  )
-})
-
-test('setUserSession should update the channel session', async () => {
-  const session = { userId: 'user123' } as CoreUserSession
-  await handler.setUserSession(session)
-  const channel = handler.getChannel()
-  assert.deepEqual(
-    channel.userSession,
-    session,
-    'Session should be updated correctly'
-  )
 })
 
 test('open should change channel state to open', () => {

package/src/channel/pikku-abstract-channel-handler.ts

@@ -1,31 +1,25 @@
-import { CoreUserSession } from '../types/core.types.js'
 import { PikkuChannel, PikkuChannelHandler } from './channel.types.js'
 
 export abstract class PikkuAbstractChannelHandler<
-  UserSession extends CoreUserSession = CoreUserSession,
   OpeningData = unknown,
   Out = unknown,
-> implements PikkuChannelHandler<UserSession, OpeningData, Out>
+> implements PikkuChannelHandler<OpeningData, Out>
 {
-  protected channel?: PikkuChannel<UserSession, OpeningData, Out>
+  protected channel?: PikkuChannel<OpeningData, Out>
 
   constructor(
     public channelId: string,
     public channelName: string,
-    protected userSession: UserSession | undefined,
     protected openingData: OpeningData
   ) {}
 
-  public abstract setUserSession(userSession: UserSession): Promise<void> | void
   public abstract send(message: Out, isBinary?: boolean): Promise<void> | void
 
-  public getChannel(): PikkuChannel<UserSession, OpeningData, Out> {
+  public getChannel(): PikkuChannel<OpeningData, Out> {
     if (!this.channel) {
       this.channel = {
         channelId: this.channelId,
-        userSession: this.userSession,
         openingData: this.openingData,
-        setUserSession: this.setUserSession.bind(this),
         send: this.send.bind(this),
         close: this.close.bind(this),
         state: 'initial',