@pikku/core 0.11.0 → 0.11.1

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/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/
       )

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

@@ -1,13 +1,7 @@
 import { NotFoundError } from '../../errors/errors.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
-import {
-  CorePikkuMiddleware,
-  CoreUserSession,
-  SessionServices,
-  PikkuWiringTypes,
-} from '../../types/core.types.js'
-import { closeSessionServices } from '../../utils.js'
+import { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js'
 import {
   CoreCLI,
   CLICommandMeta,
@@ -20,14 +14,13 @@ import {
 import type {
   CoreSingletonServices,
   CoreServices,
-  CreateSessionServices,
-  PikkuInteraction,
+  CreateWireServices,
+  PikkuWire,
   CreateConfig,
   CreateSingletonServices,
 } from '../../types/core.types.js'
 import { PikkuChannel } from '../channel/channel.types.js'
-import { rpcService } from '../rpc/rpc-runner.js'
-import { PikkuUserSessionService } from '../../services/user-session-service.js'
+import { PikkuSessionService } from '../../services/user-session-service.js'
 import { LocalVariablesService } from '../../services/local-variables.js'
 import { generateCommandHelp, parseCLIArguments } from './command-parser.js'
 
@@ -247,13 +240,13 @@ export async function runCLICommand({
   commandPath,
   data,
   singletonServices,
-  createSessionServices,
+  createWireServices,
 }: {
   program: string
   commandPath: string[]
   data: Record<string, any>
   singletonServices: CoreSingletonServices
-  createSessionServices?: CreateSessionServices
+  createWireServices?: CreateWireServices
 }): Promise<any> {
   // Get the command metadata to find the function name
   const cliMeta = pikkuState('cli', 'meta')
@@ -329,57 +322,31 @@ export async function runCLICommand({
     state: 'open',
   }
 
-  const userSession = new PikkuUserSessionService<CoreUserSession>()
-  let sessionServices: SessionServices | undefined
+  const userSession = new PikkuSessionService<CoreUserSession>()
 
-  const interaction: PikkuInteraction = {
+  const wire: PikkuWire = {
     cli: {
       program,
       command: commandPath,
       data: pluckedData,
       channel,
     },
-  }
-
-  const getAllServices = async (session?: CoreUserSession) => {
-    // Create session-specific services for handling the command
-    sessionServices = await createSessionServices?.(
-      singletonServices,
-      interaction,
-      session
-    )
-
-    return rpcService.injectRPCService(
-      {
-        ...singletonServices,
-        ...sessionServices,
-        userSession,
-        channel,
-      },
-      interaction,
-      false
-    )
+    session: userSession,
   }
 
   try {
-    const result = await runPikkuFunc(
-      PikkuWiringTypes.cli,
-      commandId,
-      funcName,
-      {
-        singletonServices,
-        getAllServices,
-        data: pluckedData,
-        auth: false,
-        userSession,
-        inheritedMiddleware: currentCommand.middleware,
-        wireMiddleware: allWireMiddleware,
-        inheritedPermissions: currentCommand.permissions,
-        wirePermissions: undefined,
-        tags: programData?.tags,
-        interaction,
-      }
-    )
+    const result = await runPikkuFunc('cli', commandId, funcName, {
+      singletonServices,
+      createWireServices,
+      data: pluckedData,
+      auth: false,
+      inheritedMiddleware: currentCommand.middleware,
+      wireMiddleware: allWireMiddleware,
+      inheritedPermissions: currentCommand.permissions,
+      wirePermissions: undefined,
+      tags: programData?.tags,
+      wire,
+    })
 
     // Apply renderer one final time with the final output (if renderer exists)
     if (renderer) {
@@ -392,11 +359,6 @@ export async function runCLICommand({
   } finally {
     // Close the channel
     channel.close()
-
-    // Clean up session services
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
-    }
   }
 }
 
@@ -428,13 +390,13 @@ export async function executeCLI({
   args,
   createConfig,
   createSingletonServices,
-  createSessionServices,
+  createWireServices,
 }: {
   programName: string
   args?: string[]
   createConfig: CreateConfig<any, any>
   createSingletonServices: CreateSingletonServices<any, any>
-  createSessionServices?: CreateSessionServices<any, any, any>
+  createWireServices?: CreateWireServices<any, any, any>
 }): Promise<void> {
   if (!args) {
     throw new Error(
@@ -518,7 +480,7 @@ export async function executeCLI({
       commandPath: parsed.commandPath,
       data,
       singletonServices,
-      createSessionServices,
+      createWireServices,
     })
   } catch (error: any) {
     // Re-throw CLIError as-is