@pikku/core 0.11.1 → 0.12.0

package/src/wirings/channel/define-channel-routes.ts

@@ -0,0 +1,25 @@
+/**
+ * Type-safe helper for defining channel message routes that can be composed.
+ * Returns the routes record as-is (identity function) for use with `wireChannel`.
+ *
+ * @example
+ * ```typescript
+ * export const chatRoutes = defineChannelRoutes({
+ *   greet: pikkuChannelFunc({ func: greetFunc }),
+ *   farewell: pikkuChannelFunc({ func: farewellFunc }),
+ * })
+ *
+ * wireChannel({
+ *   name: 'chat',
+ *   route: '/ws/chat',
+ *   onMessageWiring: {
+ *     command: chatRoutes,
+ *   }
+ * })
+ * ```
+ */
+export function defineChannelRoutes<T extends Record<string, any>>(
+  routes: T
+): T {
+  return routes
+}

package/src/wirings/channel/index.ts

@@ -1,8 +1,23 @@
-export * from './channel-runner.js'
-export * from './channel.types.js'
-export * from './log-channels.js'
-export * from './pikku-abstract-channel-handler.js'
-export * from './eventhub-service.js'
-export * from './eventhub-service.js'
-export * from './channel-store.js'
-export * from './eventhub-store.js'
+export { wireChannel, openChannel } from './channel-runner.js'
+export {
+  addChannelMiddleware,
+  combineChannelMiddleware,
+  wrapChannelWithMiddleware,
+} from './channel-middleware-runner.js'
+export { logChannels } from './log-channels.js'
+export { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js'
+export type { EventHubService } from './eventhub-service.js'
+export { ChannelStore } from './channel-store.js'
+export type { Channel } from './channel-store.js'
+export { EventHubStore } from './eventhub-store.js'
+export type {
+  ChannelsMeta,
+  CoreChannel,
+  CorePikkuChannelMiddleware,
+  CorePikkuChannelMiddlewareFactory,
+  ChannelMessageMeta,
+  ChannelMeta,
+  PikkuChannel,
+  PikkuChannelHandlerFactory,
+} from './channel.types.js'
+export { defineChannelRoutes } from './define-channel-routes.js'

package/src/wirings/channel/local/index.ts

@@ -1,3 +1,3 @@
-export * from './local-channel-handler.js'
-export * from './local-channel-runner.js'
-export * from './local-eventhub-service.js'
+export { PikkuLocalChannelHandler } from './local-channel-handler.js'
+export { runLocalChannel } from './local-channel-runner.js'
+export { LocalEventHubService } from './local-eventhub-service.js'

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

@@ -101,10 +101,12 @@ const mockCreateWireServices = async () => ({
 
 beforeEach(() => {
   resetPikkuState()
+  httpRouter.reset()
 })
 
 afterEach(() => {
   resetPikkuState()
+  httpRouter.reset()
 })
 
 test('runChannel should return undefined and 404 if no matching channel is found', async () => {
@@ -130,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',
@@ -158,6 +160,49 @@ test('runChannel should return a channel handler if channel matches and no auth
 
   // Simulate opening the channel
   result.open()
+})
+
+test('runChannel should close wire services once when channel closes', async () => {
+  resetPikkuState()
+  let closeCount = 0
+
+  pikkuState(null, 'channel', 'meta', {
+    test: {
+      name: 'test',
+      route: '/test-channel',
+    },
+  } as any)
+  wireChannel({
+    name: 'test',
+    route: '/test-channel',
+    auth: false,
+  })
+
+  httpRouter.initialize()
+
+  const result = await runLocalChannel({
+    singletonServices: mockSingletonServices,
+    channelId: 'test-channel-id',
+    request: new PikkuMockRequest('/test-channel', 'get'),
+    response: new PikkuMockResponse(),
+    route: '/test-channel',
+    createWireServices: async () => ({
+      tracked: {
+        close: async () => {
+          closeCount += 1
+        },
+      },
+    }),
+  })
+
+  assert.ok(result)
+  assert.equal(closeCount, 0)
+
+  result.close()
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  assert.equal(closeCount, 1)
 
-  // TODO: Test that the opened channel works
+  result.close()
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  assert.equal(closeCount, 1)
 })

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

@@ -10,7 +10,10 @@ import {
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
 import { PikkuWire, WireServices } from '../../../types/core.types.js'
 import { handleHTTPError } from '../../../handle-error.js'
-import { PikkuSessionService } from '../../../services/user-session-service.js'
+import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+} from '../../../services/user-session-service.js'
 import { PikkuHTTP } from '../../http/http.types.js'
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
 
@@ -30,6 +33,7 @@ export const runLocalChannel = async ({
   RunChannelOptions &
   RunChannelParams<unknown>): Promise<PikkuLocalChannelHandler | void> => {
   let wireServices: WireServices<typeof singletonServices> | undefined
+  let closedWireServices = false
 
   let channelHandler: PikkuLocalChannelHandler | undefined
   const userSession = new PikkuSessionService()
@@ -75,12 +79,23 @@ export const runLocalChannel = async ({
         openingData
       )
       const channel = channelHandler.getChannel()
-      const wire: PikkuWire = { channel, session: userSession }
+      const wire: PikkuWire = {
+        channel,
+        ...createMiddlewareSessionWireProps(userSession),
+      }
 
       if (createWireServices) {
         wireServices = await createWireServices(singletonServices, wire)
       }
 
+      const closeServices = async () => {
+        if (!wireServices || closedWireServices) {
+          return
+        }
+        closedWireServices = true
+        await closeWireServices(singletonServices.logger, wireServices)
+      }
+
       const services = { ...singletonServices, ...wireServices }
 
       channelHandler.registerOnOpen(async () => {
@@ -94,6 +109,7 @@ export const runLocalChannel = async ({
               services,
               channel,
               data: openingData,
+              channelMiddlewareMeta: meta.channelMiddleware,
             })
             if (result !== undefined) {
               await channel.send(result)
@@ -115,6 +131,7 @@ export const runLocalChannel = async ({
               lifecycleType: 'disconnect',
               services,
               channel,
+              channelMiddlewareMeta: meta.channelMiddleware,
             })
           } catch (e) {
             singletonServices.logger.error(`Error handling onDisconnect: ${e}`)
@@ -122,9 +139,7 @@ export const runLocalChannel = async ({
           }
         }
 
-        if (wireServices) {
-          await closeWireServices(singletonServices.logger, wireServices)
-        }
+        await closeServices()
       })
 
       const onMessage = processMessageHandlers(
@@ -153,7 +168,8 @@ export const runLocalChannel = async ({
         bubbleErrors
       )
     } finally {
-      if (wireServices) {
+      if (!channelHandler && wireServices && !closedWireServices) {
+        closedWireServices = true
         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/index.ts

@@ -1 +1,5 @@
-export * from './serverless-channel-runner.js'
+export {
+  runChannelConnect,
+  runChannelDisconnect,
+  runChannelMessage,
+} from './serverless-channel-runner.js'

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

@@ -11,7 +11,10 @@ import type {
 import { createHTTPWire } from '../../http/http-runner.js'
 import { ChannelStore } from '../channel-store.js'
 import { handleHTTPError } from '../../../handle-error.js'
-import { PikkuSessionService } from '../../../services/user-session-service.js'
+import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+} 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'
@@ -35,9 +38,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}`)
@@ -107,7 +110,10 @@ export const runChannelConnect = async ({
       channelName: channelConfig.name,
     })
 
-    const wire: PikkuWire = { channel, session: userSession }
+    const wire: PikkuWire = {
+      channel,
+      ...createMiddlewareSessionWireProps(userSession),
+    }
 
     if (createWireServices) {
       wireServices = await createWireServices(singletonServices, wire)
@@ -127,6 +133,7 @@ export const runChannelConnect = async ({
         services,
         channel,
         data: openingData,
+        channelMiddlewareMeta: meta.channelMiddleware,
       })
     }
     http?.response?.status(101)
@@ -175,12 +182,16 @@ export const runChannelDisconnect = async ({
     openingData,
     channelName,
   })
+
   const userSession = new PikkuSessionService(
     params.channelStore,
     params.channelId
   )
   userSession.setInitial(session)
-  const wire: PikkuWire = { channel, session: userSession }
+  const wire: PikkuWire = {
+    channel,
+    ...createMiddlewareSessionWireProps(userSession),
+  }
 
   if (!wireServices && params.createWireServices) {
     wireServices = await params.createWireServices(singletonServices, wire)
@@ -200,6 +211,7 @@ export const runChannelDisconnect = async ({
         lifecycleType: 'disconnect',
         services,
         channel,
+        channelMiddlewareMeta: meta.channelMiddleware,
       })
     } catch (e: any) {
       singletonServices.logger.error(
@@ -226,12 +238,16 @@ export const runChannelMessage = async (
     openingData,
     channelName,
   })
+
   const userSession = new PikkuSessionService(
     params.channelStore,
     params.channelId
   )
   userSession.setInitial(session)
-  const wire: PikkuWire = { channel, session: userSession }
+  const wire: PikkuWire = {
+    channel,
+    ...createMiddlewareSessionWireProps(userSession),
+  }
 
   if (params.createWireServices) {
     wireServices = await params.createWireServices(singletonServices, wire)

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

package/src/wirings/cli/channel/index.ts

@@ -1 +1 @@
-export * from './cli-channel-runner.js'
+export { executeCLIViaChannel } from './cli-channel-runner.js'

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

@@ -30,7 +30,7 @@ describe('CLI Runner', () => {
 
   describe('runCLICommand', () => {
     test('should throw NotFoundError when program not found', async () => {
-      pikkuState('cli', 'meta', { programs: {}, renderers: {} })
+      pikkuState(null, 'cli', 'meta', { programs: {}, renderers: {} })
 
       await assert.rejects(
         async () =>
@@ -45,7 +45,7 @@ describe('CLI Runner', () => {
     })
 
     test('should throw NotFoundError when command not found', async () => {
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'test-cli': {
             program: 'test-cli',
@@ -56,7 +56,7 @@ describe('CLI Runner', () => {
         renderers: {},
       })
 
-      pikkuState('cli', 'programs', {
+      pikkuState(null, 'cli', 'programs', {
         'test-cli': {
           defaultRenderer: undefined,
           middleware: [],
@@ -84,14 +84,14 @@ describe('CLI Runner', () => {
       }
 
       // Setup metadata
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'test-cli': {
             program: 'test-cli',
             commands: {
               greet: {
                 command: 'greet <name>',
-                pikkuFuncName: 'greetFunc',
+                pikkuFuncId: 'greetFunc',
                 positionals: [{ name: 'name', required: true }],
                 options: {},
               },
@@ -102,7 +102,7 @@ describe('CLI Runner', () => {
         renderers: {},
       })
 
-      pikkuState('cli', 'programs', {
+      pikkuState(null, 'cli', 'programs', {
         'test-cli': {
           defaultRenderer: undefined,
           middleware: [],
@@ -110,9 +110,9 @@ describe('CLI Runner', () => {
         },
       })
 
-      pikkuState('function', 'meta', {
+      pikkuState(null, 'function', 'meta', {
         greetFunc: {
-          pikkuFuncName: 'greetFunc',
+          pikkuFuncId: 'greetFunc',
           inputSchemaName: null,
           outputSchemaName: null,
         },
@@ -148,14 +148,14 @@ describe('CLI Runner', () => {
         return { success: true }
       }
 
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'test-cli': {
             program: 'test-cli',
             commands: {
               test: {
                 command: 'test',
-                pikkuFuncName: 'testFunc',
+                pikkuFuncId: 'testFunc',
                 positionals: [],
                 options: {},
               },
@@ -166,7 +166,7 @@ describe('CLI Runner', () => {
         renderers: {},
       })
 
-      pikkuState('cli', 'programs', {
+      pikkuState(null, 'cli', 'programs', {
         'test-cli': {
           defaultRenderer: undefined,
           middleware: [testMiddleware],
@@ -174,9 +174,9 @@ describe('CLI Runner', () => {
         },
       })
 
-      pikkuState('function', 'meta', {
+      pikkuState(null, 'function', 'meta', {
         testFunc: {
-          pikkuFuncName: 'testFunc',
+          pikkuFuncId: 'testFunc',
           inputSchemaName: null,
           outputSchemaName: null,
         },
@@ -208,14 +208,14 @@ describe('CLI Runner', () => {
 
       const testFunc = async () => ({ success: true })
 
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'test-cli': {
             program: 'test-cli',
             commands: {
               greet: {
                 command: 'greet <name>',
-                pikkuFuncName: 'greetFunc',
+                pikkuFuncId: 'greetFunc',
                 positionals: [{ name: 'name', required: true }],
                 options: {},
               },
@@ -226,7 +226,7 @@ describe('CLI Runner', () => {
         renderers: {},
       })
 
-      pikkuState('cli', 'programs', {
+      pikkuState(null, 'cli', 'programs', {
         'test-cli': {
           defaultRenderer: undefined,
           middleware: [testMiddleware],
@@ -234,9 +234,9 @@ describe('CLI Runner', () => {
         },
       })
 
-      pikkuState('function', 'meta', {
+      pikkuState(null, 'function', 'meta', {
         greetFunc: {
-          pikkuFuncName: 'greetFunc',
+          pikkuFuncId: 'greetFunc',
           inputSchemaName: null,
           outputSchemaName: null,
         },
@@ -260,14 +260,14 @@ describe('CLI Runner', () => {
     test('should throw error when auth required but no session', async () => {
       const testFunc = async () => ({ success: true })
 
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'test-cli': {
             program: 'test-cli',
             commands: {
               secure: {
                 command: 'secure',
-                pikkuFuncName: 'secureFunc',
+                pikkuFuncId: 'secureFunc',
                 positionals: [],
                 options: {},
               },
@@ -278,9 +278,9 @@ describe('CLI Runner', () => {
         renderers: {},
       })
 
-      pikkuState('function', 'meta', {
+      pikkuState(null, 'function', 'meta', {
         secureFunc: {
-          pikkuFuncName: 'secureFunc',
+          pikkuFuncId: 'secureFunc',
           inputSchemaName: null,
           outputSchemaName: null,
         },
@@ -306,14 +306,14 @@ describe('CLI Runner', () => {
     test('should register CLI program and commands', () => {
       const greetFunc = async () => 'Hello'
 
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'my-cli': {
             program: 'my-cli',
             commands: {
               greet: {
                 command: 'greet <name>',
-                pikkuFuncName: 'greetFunc',
+                pikkuFuncId: 'greetFunc',
                 positionals: [{ name: 'name', required: true }],
                 options: {
                   loud: {
@@ -337,7 +337,7 @@ describe('CLI Runner', () => {
         },
       })
 
-      const programs = pikkuState('cli', 'programs')
+      const programs = pikkuState(null, 'cli', 'programs')
       assert.ok(programs['my-cli'])
       assert.strictEqual(programs['my-cli'].middleware.length, 0)
     })
@@ -347,7 +347,7 @@ describe('CLI Runner', () => {
         await next()
       }
 
-      pikkuState('cli', 'meta', {
+      pikkuState(null, 'cli', 'meta', {
         programs: {
           'my-cli': {
             program: 'my-cli',
@@ -364,13 +364,13 @@ describe('CLI Runner', () => {
         middleware: [middleware],
       })
 
-      const programs = pikkuState('cli', 'programs')
+      const programs = pikkuState(null, 'cli', 'programs')
       assert.strictEqual(programs['my-cli'].middleware.length, 1)
       assert.strictEqual(programs['my-cli'].middleware[0], middleware)
     })
 
     test('should throw error when CLI metadata not found', () => {
-      pikkuState('cli', 'meta', { programs: {}, renderers: {} })
+      pikkuState(null, 'cli', 'meta', { programs: {}, renderers: {} })
 
       assert.throws(() => {
         wireCLI({