@pikku/core 0.10.2 → 0.11.1

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

@@ -2,7 +2,6 @@ import {
   CoreServices,
   JSONValue,
   CoreUserSession,
-  PikkuWiringTypes,
 } from '../../types/core.types.js'
 import {
   ChannelMessageMeta,
@@ -11,6 +10,7 @@ import {
 } from './channel.types.js'
 import { pikkuState } from '../../pikku-state.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
+import { SessionService } from '../../services/user-session-service.js'
 
 const getRouteMeta = (
   channelName: string,
@@ -62,7 +62,8 @@ const validateAuth = (
 export const processMessageHandlers = (
   services: CoreServices,
   channelConfig: CoreChannel<any, any>,
-  channelHandler: PikkuChannelHandler
+  channelHandler: PikkuChannelHandler,
+  userSession?: SessionService<CoreUserSession>
 ) => {
   const logger = services.logger
   const requiresSession = channelConfig.auth !== false
@@ -121,26 +122,19 @@ export const processMessageHandlers = (
       ? `${channelConfig.name}:${routingProperty}:${routerValue}`
       : `${channelConfig.name}:default`
 
-    return await runPikkuFunc(
-      PikkuWiringTypes.channel,
-      cacheKey,
-      pikkuFuncName,
-      {
-        singletonServices: services,
-        getAllServices: () => ({
-          ...services,
-          channel: channelHandler.getChannel(),
-        }),
-        data: () => data,
-        userSession: services.userSession,
-        inheritedMiddleware,
-        wireMiddleware,
-        inheritedPermissions,
-        wirePermissions,
-        tags: channelConfig.tags,
-        interaction: { channel: channelHandler.getChannel() },
-      }
-    )
+    return await runPikkuFunc('channel', cacheKey, pikkuFuncName, {
+      singletonServices: services,
+      data: () => data,
+      inheritedMiddleware,
+      wireMiddleware,
+      inheritedPermissions,
+      wirePermissions,
+      tags: channelConfig.tags,
+      wire: {
+        channel: channelHandler.getChannel(),
+        session: userSession,
+      },
+    })
   }
 
   return async (rawData): Promise<unknown> => {

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

@@ -3,7 +3,7 @@ import { addFunction } from '../../function/function-runner.js'
 import { CorePikkuPermission } from '../../function/functions.types.js'
 import { pikkuState } from '../../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js'
-import { UserSessionService } from '../../services/user-session-service.js'
+import { SessionService } from '../../services/user-session-service.js'
 import { CorePikkuMiddleware } from '../../types/core.types.js'
 import { httpRouter } from '../http/routers/http-router.js'
 import {
@@ -128,7 +128,7 @@ export const openChannel = async ({
   request,
 }: Pick<CoreChannel<unknown, string>, 'route'> &
   RunChannelParams<unknown> & {
-    userSession: UserSessionService<any>
+    userSession: SessionService<any>
   } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreChannel<unknown, any>

package/src/wirings/channel/channel.types.ts

@@ -5,9 +5,8 @@ import {
   PikkuHTTPResponse,
 } from '../http/http.types.js'
 import {
-  PikkuDocs,
   CoreSingletonServices,
-  CreateSessionServices,
+  CreateWireServices,
   CorePikkuMiddleware,
   MiddlewareMetadata,
   PermissionMetadata,
@@ -33,12 +32,15 @@ export type RunChannelParams<ChannelData> = {
   singletonServices: CoreSingletonServices
   request?: PikkuHTTPRequest<ChannelData>
   response?: PikkuHTTPResponse
-  createSessionServices?: CreateSessionServices
+  createWireServices?: CreateWireServices
 }
 
 export interface ChannelMessageMeta {
   pikkuFuncName: string
-  docs?: PikkuDocs
+  summary?: string
+  description?: string
+  errors?: string[]
+  tags?: string[]
   middleware?: MiddlewareMetadata[]
   permissions?: PermissionMetadata[]
 }
@@ -54,7 +56,9 @@ export interface ChannelMeta {
   disconnect: ChannelMessageMeta | null
   message: ChannelMessageMeta | null
   messageWirings: Record<string, Record<string, ChannelMessageMeta>>
-  docs?: PikkuDocs
+  summary?: string
+  description?: string
+  errors?: string[]
   tags?: string[]
   middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
   permissions?: PermissionMetadata[] // Pre-resolved permission chain (tag + explicit)
@@ -66,20 +70,19 @@ export type CoreChannel<
   ChannelData,
   Channel extends string,
   ChannelConnect = CorePikkuFunctionConfig<
-    | CorePikkuFunction<void, unknown, ChannelData>
-    | CorePikkuFunctionSessionless<void, unknown, ChannelData>,
+    | CorePikkuFunction<void, unknown>
+    | CorePikkuFunctionSessionless<void, unknown>,
     CorePikkuPermission<void>,
     CorePikkuMiddleware
   >,
   ChannelDisconnect = CorePikkuFunctionConfig<
-    | CorePikkuFunction<void, void, ChannelData>
-    | CorePikkuFunctionSessionless<void, void, ChannelData>,
+    CorePikkuFunction<void, void> | CorePikkuFunctionSessionless<void, void>,
     CorePikkuPermission<void>,
     CorePikkuMiddleware
   >,
   ChannelFunctionMessage = CorePikkuFunctionConfig<
-    | CorePikkuFunction<unknown, unknown, ChannelData>
-    | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>,
+    | CorePikkuFunction<unknown, unknown>
+    | CorePikkuFunctionSessionless<unknown, unknown>,
     CorePikkuPermission<unknown>,
     CorePikkuMiddleware
   >,

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

@@ -95,7 +95,9 @@ export class PikkuMockResponse implements PikkuHTTPResponse {
   }
 }
 
-const mockCreateSessionServices = async () => ({ sessionServiceMock: true })
+const mockCreateWireServices = async () => ({
+  wireServiceMock: true,
+})
 
 beforeEach(() => {
   resetPikkuState()
@@ -113,7 +115,7 @@ test('runChannel should return undefined and 404 if no matching channel is found
     channelId: 'test-channel-id',
     request: new PikkuMockRequest('/non-existent-channel', 'get'),
     response: mockResponse,
-    createSessionServices: mockCreateSessionServices,
+    createWireServices: mockCreateWireServices,
   })
 
   assert.equal(
@@ -149,7 +151,7 @@ test('runChannel should return a channel handler if channel matches and no auth
     request: new PikkuMockRequest('/test-channel', 'get'),
     response: new PikkuMockResponse(),
     route: '/test-channel',
-    createSessionServices: mockCreateSessionServices,
+    createWireServices: mockCreateWireServices,
   })
 
   assert.ok(result, 'Should return a PikkuChannelHandler instance')

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

@@ -1,6 +1,6 @@
 import { openChannel } from '../channel-runner.js'
-import { createHTTPInteraction } from '../../http/http-runner.js'
-import { closeSessionServices } from '../../../utils.js'
+import { createHTTPWire } from '../../http/http-runner.js'
+import { closeWireServices } from '../../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import {
   CoreChannel,
@@ -8,11 +8,10 @@ import {
   RunChannelParams,
 } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
-import { PikkuInteraction, SessionServices } from '../../../types/core.types.js'
+import { PikkuWire, WireServices } from '../../../types/core.types.js'
 import { handleHTTPError } from '../../../handle-error.js'
-import { PikkuUserSessionService } from '../../../services/user-session-service.js'
+import { PikkuSessionService } from '../../../services/user-session-service.js'
 import { PikkuHTTP } from '../../http/http.types.js'
-import { rpcService } from '../../rpc/rpc-runner.js'
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
 
 export const runLocalChannel = async ({
@@ -21,7 +20,7 @@ export const runLocalChannel = async ({
   request,
   response,
   route,
-  createSessionServices,
+  createWireServices,
   skipUserSession = false,
   respondWith404 = true,
   coerceDataFromSchema = true,
@@ -30,14 +29,14 @@ export const runLocalChannel = async ({
 }: Partial<Pick<CoreChannel<unknown, any>, 'route'>> &
   RunChannelOptions &
   RunChannelParams<unknown>): Promise<PikkuLocalChannelHandler | void> => {
-  let sessionServices: SessionServices<typeof singletonServices> | undefined
+  let wireServices: WireServices<typeof singletonServices> | undefined
 
   let channelHandler: PikkuLocalChannelHandler | undefined
-  const userSession = new PikkuUserSessionService()
+  const userSession = new PikkuSessionService()
 
   let http: PikkuHTTP | undefined
   if (request) {
-    http = createHTTPInteraction(request, response)
+    http = createHTTPWire(request, response)
     route = http?.request?.path()
   }
 
@@ -45,7 +44,7 @@ export const runLocalChannel = async ({
   try {
     ;({ openingData, channelConfig, meta } = await openChannel({
       channelId,
-      createSessionServices,
+      createWireServices,
       respondWith404,
       request,
       response,
@@ -76,28 +75,13 @@ export const runLocalChannel = async ({
         openingData
       )
       const channel = channelHandler.getChannel()
-      const session = await userSession.get()
-      if (createSessionServices) {
-        sessionServices = await createSessionServices(
-          singletonServices,
-          { http, channel },
-          session
-        )
-      }
+      const wire: PikkuWire = { channel, session: userSession }
 
-      const getAllServices = (channel: any, requiresAuth?: boolean) =>
-        rpcService.injectRPCService(
-          {
-            ...singletonServices,
-            ...sessionServices,
-            channel,
-            userSession,
-          },
-          interaction,
-          requiresAuth
-        )
+      if (createWireServices) {
+        wireServices = await createWireServices(singletonServices, wire)
+      }
 
-      const interaction: PikkuInteraction = { channel }
+      const services = { ...singletonServices, ...wireServices }
 
       channelHandler.registerOnOpen(async () => {
         if (channelConfig.onConnect && meta.connect) {
@@ -107,7 +91,7 @@ export const runLocalChannel = async ({
               meta: meta.connect,
               lifecycleConfig: channelConfig.onConnect,
               lifecycleType: 'connect',
-              services: getAllServices(channel, false),
+              services,
               channel,
               data: openingData,
             })
@@ -129,7 +113,7 @@ export const runLocalChannel = async ({
               meta: meta.disconnect,
               lifecycleConfig: channelConfig.onDisconnect,
               lifecycleType: 'disconnect',
-              services: getAllServices(channel, false),
+              services,
               channel,
             })
           } catch (e) {
@@ -138,15 +122,16 @@ export const runLocalChannel = async ({
           }
         }
 
-        if (sessionServices) {
-          await closeSessionServices(singletonServices.logger, sessionServices)
+        if (wireServices) {
+          await closeWireServices(singletonServices.logger, wireServices)
         }
       })
 
       const onMessage = processMessageHandlers(
-        getAllServices(channel),
+        services,
         channelConfig as any,
-        channelHandler
+        channelHandler,
+        userSession
       )
       channelHandler.registerOnMessage(async (data) => {
         try {
@@ -168,8 +153,8 @@ export const runLocalChannel = async ({
         bubbleErrors
       )
     } finally {
-      if (sessionServices) {
-        await closeSessionServices(singletonServices.logger, sessionServices)
+      if (wireServices) {
+        await closeWireServices(singletonServices.logger, wireServices)
       }
     }
   }

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

@@ -1,5 +1,5 @@
-import { PikkuInteraction, SessionServices } from '../../../types/core.types.js'
-import { closeSessionServices } from '../../../utils.js'
+import { PikkuWire, WireServices } from '../../../types/core.types.js'
+import { closeWireServices } from '../../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import { openChannel } from '../channel-runner.js'
 import type {
@@ -8,15 +8,14 @@ import type {
   RunChannelParams,
   PikkuChannelHandlerFactory,
 } from '../channel.types.js'
-import { createHTTPInteraction } from '../../http/http-runner.js'
+import { createHTTPWire } from '../../http/http-runner.js'
 import { ChannelStore } from '../channel-store.js'
 import { handleHTTPError } from '../../../handle-error.js'
-import { PikkuUserSessionService } from '../../../services/user-session-service.js'
+import { PikkuSessionService } from '../../../services/user-session-service.js'
 import { pikkuState } from '../../../pikku-state.js'
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js'
 import { PikkuHTTP } from '../../http/http.types.js'
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
-import { rpcService } from '../../rpc/rpc-runner.js'
 
 export interface RunServerlessChannelParams<ChannelData>
   extends RunChannelParams<ChannelData> {
@@ -66,7 +65,7 @@ export const runChannelConnect = async ({
   request,
   response,
   route,
-  createSessionServices,
+  createWireServices,
   channelStore,
   channelHandlerFactory,
   coerceDataFromSchema = true,
@@ -76,18 +75,18 @@ export const runChannelConnect = async ({
 }: Pick<CoreChannel<unknown, any>, 'route'> &
   RunChannelOptions &
   RunServerlessChannelParams<unknown>) => {
-  let sessionServices: SessionServices | undefined
+  let wireServices: WireServices | undefined
 
   let http: PikkuHTTP | undefined
   if (request instanceof Request) {
-    http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response)
+    http = createHTTPWire(new PikkuFetchHTTPRequest(request), response)
   }
 
-  const userSession = new PikkuUserSessionService(channelStore, channelId)
+  const userSession = new PikkuSessionService(channelStore, channelId)
 
   const { channelConfig, openingData, meta } = await openChannel({
     channelId,
-    createSessionServices,
+    createWireServices,
     request,
     route,
     singletonServices,
@@ -107,26 +106,17 @@ export const runChannelConnect = async ({
       channelHandlerFactory,
       channelName: channelConfig.name,
     })
-    if (createSessionServices) {
-      sessionServices = await createSessionServices(
-        singletonServices,
-        { http },
-        await userSession.get()
-      )
+
+    const wire: PikkuWire = { channel, session: userSession }
+
+    if (createWireServices) {
+      wireServices = await createWireServices(singletonServices, wire)
     }
 
-    const interaction: PikkuInteraction = { channel }
-    const getAllServices = (requiresAuth?: boolean) =>
-      rpcService.injectRPCService(
-        {
-          ...singletonServices,
-          ...sessionServices,
-          channel,
-          userSession,
-        },
-        interaction,
-        requiresAuth
-      )
+    const services = {
+      ...singletonServices,
+      ...wireServices,
+    }
 
     if (channelConfig.onConnect && meta.connect) {
       await runChannelLifecycleWithMiddleware({
@@ -134,7 +124,7 @@ export const runChannelConnect = async ({
         meta: meta.connect,
         lifecycleConfig: channelConfig.onConnect,
         lifecycleType: 'connect',
-        services: getAllServices(false),
+        services,
         channel,
         data: openingData,
       })
@@ -151,8 +141,8 @@ export const runChannelConnect = async ({
       bubbleErrors
     )
   } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
+    if (wireServices) {
+      await closeWireServices(singletonServices.logger, wireServices)
     }
   }
 }
@@ -161,7 +151,7 @@ export const runChannelDisconnect = async ({
   singletonServices,
   ...params
 }: RunServerlessChannelParams<unknown>): Promise<void> => {
-  let sessionServices: SessionServices | undefined
+  let wireServices: WireServices | undefined
 
   // Try to get channel from store. In serverless environments (especially with
   // serverless-offline or worker threads), disconnect can be called multiple times
@@ -185,30 +175,21 @@ export const runChannelDisconnect = async ({
     openingData,
     channelName,
   })
-  const userSession = new PikkuUserSessionService(
+  const userSession = new PikkuSessionService(
     params.channelStore,
     params.channelId
   )
-  if (!sessionServices && params.createSessionServices) {
-    sessionServices = await params.createSessionServices(
-      singletonServices,
-      { channel },
-      session
-    )
+  userSession.setInitial(session)
+  const wire: PikkuWire = { channel, session: userSession }
+
+  if (!wireServices && params.createWireServices) {
+    wireServices = await params.createWireServices(singletonServices, wire)
   }
 
-  const interaction: PikkuInteraction = { channel }
-  const getAllServices = (requiresAuth?: boolean) =>
-    rpcService.injectRPCService(
-      {
-        ...singletonServices,
-        ...sessionServices,
-        channel,
-        userSession,
-      },
-      interaction,
-      requiresAuth
-    )
+  const services = {
+    ...singletonServices,
+    ...wireServices,
+  }
 
   if (channelConfig.onDisconnect && meta.disconnect) {
     try {
@@ -217,7 +198,7 @@ export const runChannelDisconnect = async ({
         meta: meta.disconnect,
         lifecycleConfig: channelConfig.onDisconnect,
         lifecycleType: 'disconnect',
-        services: getAllServices(false),
+        services,
         channel,
       })
     } catch (e: any) {
@@ -227,8 +208,8 @@ export const runChannelDisconnect = async ({
     }
   }
   await params.channelStore.removeChannels([channel.channelId])
-  if (sessionServices) {
-    await closeSessionServices(singletonServices.logger, sessionServices)
+  if (wireServices) {
+    await closeWireServices(singletonServices.logger, wireServices)
   }
 }
 
@@ -236,7 +217,7 @@ export const runChannelMessage = async (
   { singletonServices, ...params }: RunServerlessChannelParams<unknown>,
   data: unknown
 ): Promise<unknown> => {
-  let sessionServices: SessionServices | undefined
+  let wireServices: WireServices | undefined
   const { openingData, channelName, session } =
     await params.channelStore.getChannelAndSession(params.channelId)
 
@@ -245,36 +226,29 @@ export const runChannelMessage = async (
     openingData,
     channelName,
   })
-  const userSession = new PikkuUserSessionService(
+  const userSession = new PikkuSessionService(
     params.channelStore,
     params.channelId
   )
-  if (params.createSessionServices) {
-    sessionServices = await params.createSessionServices(
-      singletonServices,
-      { channel },
-      session
-    )
+  userSession.setInitial(session)
+  const wire: PikkuWire = { channel, session: userSession }
+
+  if (params.createWireServices) {
+    wireServices = await params.createWireServices(singletonServices, wire)
   }
 
-  const interaction: PikkuInteraction = { channel }
-  const getAllServices = () =>
-    rpcService.injectRPCService(
-      {
-        ...singletonServices,
-        ...sessionServices,
-        channel,
-        userSession,
-      },
-      interaction
-    )
+  const services = {
+    ...singletonServices,
+    ...wireServices,
+  }
 
   let response: unknown
   try {
     const onMessage = processMessageHandlers(
-      getAllServices(),
+      services,
       channelConfig,
-      channelHandler
+      channelHandler,
+      userSession
     )
     response = await onMessage(data)
   } catch (e: any) {
@@ -283,8 +257,8 @@ export const runChannelMessage = async (
     )
     return { error: e.message || 'Unknown error' }
   } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
+    if (wireServices) {
+      await closeWireServices(singletonServices.logger, wireServices)
     }
   }
   return response

package/src/wirings/cli/channel/cli-channel-runner.ts

@@ -30,7 +30,7 @@ export async function executeCLIViaChannel({
   const allCLIMeta = pikkuState('cli', 'meta') as unknown as CLIMeta | undefined
   if (!allCLIMeta) {
     throw new Error(
-      '[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/errors/pku342 for more information.'
+      '[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.'
     )
   }
   const programMeta = allCLIMeta.programs[programName]

package/src/wirings/cli/cli-runner.test.ts

@@ -8,7 +8,7 @@ import { addFunction } from '../../function/function-runner.js'
 
 describe('CLI Runner', () => {
   let singletonServices: any
-  let createSessionServices: any
+  let createWireServices: any
 
   beforeEach(() => {
     resetPikkuState()
@@ -21,7 +21,7 @@ describe('CLI Runner', () => {
       },
     }
 
-    createSessionServices = async () => ({})
+    createWireServices = async () => ({})
   })
 
   afterEach(() => {
@@ -78,7 +78,7 @@ describe('CLI Runner', () => {
 
     test('should execute command function with merged data', async () => {
       let receivedData: any
-      const testFunc = async (_services: any, data: any) => {
+      const testFunc = async (_services: any, data: any, _wire: any) => {
         receivedData = data
         return { success: true }
       }
@@ -136,7 +136,7 @@ describe('CLI Runner', () => {
 
       const testMiddleware: CorePikkuMiddleware = async (
         _services,
-        _interaction,
+        _wire,
         next
       ) => {
         executionOrder.push('middleware')
@@ -199,10 +199,10 @@ describe('CLI Runner', () => {
 
       const testMiddleware: CorePikkuMiddleware = async (
         _services,
-        interaction,
+        wire,
         next
       ) => {
-        cliContext = interaction.cli
+        cliContext = wire.cli
         await next()
       }
 
@@ -295,7 +295,7 @@ describe('CLI Runner', () => {
             commandPath: ['secure'],
             data: {},
             singletonServices,
-            createSessionServices,
+            createWireServices,
           }),
         /Authentication required/
       )