@pikku/core 0.11.0 → 0.11.2

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,14 +95,18 @@ export class PikkuMockResponse implements PikkuHTTPResponse {
   }
 }
 
-const mockCreateSessionServices = async () => ({ sessionServiceMock: true })
+const mockCreateWireServices = async () => ({
+  wireServiceMock: true,
+})
 
 beforeEach(() => {
   resetPikkuState()
+  httpRouter.reset()
 })
 
 afterEach(() => {
   resetPikkuState()
+  httpRouter.reset()
 })
 
 test('runChannel should return undefined and 404 if no matching channel is found', async () => {
@@ -113,7 +117,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(
@@ -128,7 +132,7 @@ test('runChannel should return undefined and 404 if no matching channel is found
 test('runChannel should return a channel handler if channel matches and no auth required', async () => {
   resetPikkuState()
 
-  pikkuState('channel', 'meta', {
+  pikkuState(null, 'channel', 'meta', {
     test: {
       name: 'test',
       route: '/test-channel',
@@ -149,7 +153,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/log-channels.ts

@@ -6,7 +6,7 @@ import { Logger } from '../../services/index.js'
  * @param logger - A logger for logging information.
  */
 export const logChannels = (logger: Logger) => {
-  const channels = pikkuState('channel', 'channels')
+  const channels = pikkuState(null, 'channel', 'channels')
   if (channels.size === 0) {
     logger.info('No channels added')
     return

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> {
@@ -36,9 +35,9 @@ const getVariablesForChannel = ({
   channelHandlerFactory: PikkuChannelHandlerFactory
   openingData?: unknown
 }) => {
-  const channels = pikkuState('channel', 'channels')
+  const channels = pikkuState(null, 'channel', 'channels')
   const channelConfig = channels.get(channelName)
-  const channelsMeta = pikkuState('channel', 'meta')
+  const channelsMeta = pikkuState(null, 'channel', 'meta')
   const meta = channelsMeta[channelName]
   if (!channelConfig) {
     throw new Error(`Channel not found: ${channelName}`)
@@ -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

@@ -1,5 +1,5 @@
 import { pikkuState } from '../../../pikku-state.js'
-import { CorePikkuCLIRender, CLIMeta } from '../cli.types.js'
+import { CorePikkuCLIRender, type CLIMeta } from '../cli.types.js'
 import { generateCommandHelp, parseCLIArguments } from '../command-parser.js'
 
 /**
@@ -27,12 +27,13 @@ export async function executeCLIViaChannel({
   defaultRenderer?: CorePikkuCLIRender<any>
 }): Promise<void> {
   // Get CLI metadata from state
-  const allCLIMeta = pikkuState('cli', 'meta') as unknown as CLIMeta | undefined
-  if (!allCLIMeta) {
+  const cliMeta = pikkuState(null, 'cli', 'meta')
+  if (!cliMeta || !('programs' in cliMeta)) {
     throw new Error(
       '[PKU342] CLI metadata not found. No CLI wirings were registered. See https://pikku.dev/docs/pikku-cli/errors/pku342 for more information.'
     )
   }
+  const allCLIMeta = cliMeta as CLIMeta
   const programMeta = allCLIMeta.programs[programName]
 
   if (!programMeta) {