@pikku/core 0.12.0 → 0.12.2

package/src/wirings/channel/local/local-eventhub-service.test.ts

@@ -1,7 +1,7 @@
 import * as assert from 'assert'
 import { test } from 'node:test'
-import { PikkuChannelHandler } from '../channel.types.js'
-import { CoreUserSession } from '../../../types/core.types.js'
+import type { PikkuChannelHandler } from '../channel.types.js'
+import type { CoreUserSession } from '../../../types/core.types.js'
 import { LocalEventHubService } from './local-eventhub-service.js'
 
 class MockChannelHandler implements PikkuChannelHandler {

package/src/wirings/channel/local/local-eventhub-service.ts

@@ -1,5 +1,5 @@
-import { PikkuChannelHandler } from '../channel.types.js'
-import { EventHubService } from '../eventhub-service.js'
+import type { PikkuChannelHandler } from '../channel.types.js'
+import type { EventHubService } from '../eventhub-service.js'
 
 /**
  * Implementation of the SubscriptionService interface.

package/src/wirings/channel/log-channels.ts

@@ -1,5 +1,5 @@
 import { pikkuState } from '../../pikku-state.js'
-import { Logger } from '../../services/index.js'
+import type { Logger } from '../../services/index.js'
 
 /**
  * Logs all the loaded channels.

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

@@ -10,6 +10,8 @@ class TestChannelHandler extends PikkuAbstractChannelHandler<
   public async send(message: { msg: string }, isBinary = false): Promise<void> {
     // Mock send implementation
   }
+
+  public sendBinary(_data: ArrayBuffer | Uint8Array): void {}
 }
 
 let handler: TestChannelHandler

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

@@ -1,4 +1,8 @@
-import { PikkuChannel, PikkuChannelHandler } from './channel.types.js'
+import type {
+  BinaryData,
+  PikkuChannel,
+  PikkuChannelHandler,
+} from './channel.types.js'
 
 export abstract class PikkuAbstractChannelHandler<
   OpeningData = unknown,
@@ -15,12 +19,15 @@ export abstract class PikkuAbstractChannelHandler<
 
   public abstract send(message: Out, isBinary?: boolean): Promise<void> | void
 
+  public abstract sendBinary(data: BinaryData): Promise<void> | void
+
   public getChannel(): PikkuChannel<OpeningData, Out> {
     if (!this.channel) {
       this.channel = {
         channelId: this.channelId,
         openingData: this.openingData,
         send: this.send.bind(this),
+        sendBinary: this.sendBinary.bind(this),
         close: this.close.bind(this),
         state: 'initial',
       }

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

@@ -1,4 +1,4 @@
-import { PikkuWire, WireServices } from '../../../types/core.types.js'
+import type { PikkuWire, WireServices } from '../../../types/core.types.js'
 import { closeWireServices } from '../../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import { openChannel } from '../channel-runner.js'
@@ -9,15 +9,19 @@ import type {
   PikkuChannelHandlerFactory,
 } from '../channel.types.js'
 import { createHTTPWire } from '../../http/http-runner.js'
-import { ChannelStore } from '../channel-store.js'
+import type { ChannelStore } from '../channel-store.js'
 import { handleHTTPError } from '../../../handle-error.js'
 import {
   PikkuSessionService,
   createMiddlewareSessionWireProps,
 } from '../../../services/user-session-service.js'
-import { pikkuState } from '../../../pikku-state.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../../pikku-state.js'
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js'
-import { PikkuHTTP } from '../../http/http.types.js'
+import type { PikkuHTTP } from '../../http/http.types.js'
 import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
 
 export interface RunServerlessChannelParams<ChannelData>
@@ -62,13 +66,11 @@ const getVariablesForChannel = ({
 }
 
 export const runChannelConnect = async ({
-  singletonServices,
   channelId,
   channelObject,
   request,
   response,
   route,
-  createWireServices,
   channelStore,
   channelHandlerFactory,
   coerceDataFromSchema = true,
@@ -78,6 +80,8 @@ export const runChannelConnect = async ({
 }: Pick<CoreChannel<unknown, any>, 'route'> &
   RunChannelOptions &
   RunServerlessChannelParams<unknown>) => {
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   let wireServices: WireServices | undefined
 
   let http: PikkuHTTP | undefined
@@ -89,10 +93,8 @@ export const runChannelConnect = async ({
 
   const { channelConfig, openingData, meta } = await openChannel({
     channelId,
-    createWireServices,
     request,
     route,
-    singletonServices,
     coerceDataFromSchema,
     userSession,
   })
@@ -155,9 +157,12 @@ export const runChannelConnect = async ({
 }
 
 export const runChannelDisconnect = async ({
-  singletonServices,
-  ...params
+  channelId,
+  channelStore,
+  channelHandlerFactory,
 }: RunServerlessChannelParams<unknown>): Promise<void> => {
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   let wireServices: WireServices | undefined
 
   // Try to get channel from store. In serverless environments (especially with
@@ -166,35 +171,31 @@ export const runChannelDisconnect = async ({
   // there's nothing to disconnect, so we can return early.
   let channelData
   try {
-    channelData = await params.channelStore.getChannelAndSession(
-      params.channelId
-    )
-  } catch (error) {
+    channelData = await channelStore.getChannelAndSession(channelId)
+  } catch {
     singletonServices.logger.info(
-      `Channel ${params.channelId} not found during disconnect - already cleaned up`
+      `Channel ${channelId} not found during disconnect - already cleaned up`
     )
     return
   }
 
   const { openingData, channelName, session } = channelData
   const { channel, channelConfig, meta } = getVariablesForChannel({
-    ...params,
+    channelId,
+    channelHandlerFactory,
     openingData,
     channelName,
   })
 
-  const userSession = new PikkuSessionService(
-    params.channelStore,
-    params.channelId
-  )
+  const userSession = new PikkuSessionService(channelStore, channelId)
   userSession.setInitial(session)
   const wire: PikkuWire = {
     channel,
     ...createMiddlewareSessionWireProps(userSession),
   }
 
-  if (!wireServices && params.createWireServices) {
-    wireServices = await params.createWireServices(singletonServices, wire)
+  if (createWireServices) {
+    wireServices = await createWireServices(singletonServices, wire)
   }
 
   const services = {
@@ -219,38 +220,42 @@ export const runChannelDisconnect = async ({
       )
     }
   }
-  await params.channelStore.removeChannels([channel.channelId])
+  await channelStore.removeChannels([channel.channelId])
   if (wireServices) {
     await closeWireServices(singletonServices.logger, wireServices)
   }
 }
 
 export const runChannelMessage = async (
-  { singletonServices, ...params }: RunServerlessChannelParams<unknown>,
+  {
+    channelId,
+    channelStore,
+    channelHandlerFactory,
+  }: RunServerlessChannelParams<unknown>,
   data: unknown
 ): Promise<unknown> => {
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   let wireServices: WireServices | undefined
   const { openingData, channelName, session } =
-    await params.channelStore.getChannelAndSession(params.channelId)
+    await channelStore.getChannelAndSession(channelId)
 
   const { channel, channelHandler, channelConfig } = getVariablesForChannel({
-    ...params,
+    channelId,
+    channelHandlerFactory,
     openingData,
     channelName,
   })
 
-  const userSession = new PikkuSessionService(
-    params.channelStore,
-    params.channelId
-  )
+  const userSession = new PikkuSessionService(channelStore, channelId)
   userSession.setInitial(session)
   const wire: PikkuWire = {
     channel,
     ...createMiddlewareSessionWireProps(userSession),
   }
 
-  if (params.createWireServices) {
-    wireServices = await params.createWireServices(singletonServices, wire)
+  if (createWireServices) {
+    wireServices = await createWireServices(singletonServices, wire)
   }
 
   const services = {
@@ -260,7 +265,7 @@ export const runChannelMessage = async (
 
   let response: unknown
   try {
-    const onMessage = processMessageHandlers(
+    const { onMessage } = processMessageHandlers(
       services,
       channelConfig,
       channelHandler,

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

@@ -1,5 +1,5 @@
 import { pikkuState } from '../../../pikku-state.js'
-import { CorePikkuCLIRender, type CLIMeta } from '../cli.types.js'
+import type { CorePikkuCLIRender, CLIMeta } from '../cli.types.js'
 import { generateCommandHelp, parseCLIArguments } from '../command-parser.js'
 
 /**

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

@@ -1,7 +1,7 @@
 import { test, describe, beforeEach, afterEach } from 'node:test'
 import * as assert from 'assert'
 import { NotFoundError } from '../../errors/errors.js'
-import { CorePikkuMiddleware } from '../../types/core.types.js'
+import type { CorePikkuMiddleware } from '../../types/core.types.js'
 import { wireCLI, runCLICommand, pikkuCLIRender } from './cli-runner.js'
 import { pikkuState, resetPikkuState } from '../../pikku-state.js'
 import { addFunction } from '../../function/function-runner.js'

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

@@ -1,8 +1,11 @@
 import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
-import { CorePikkuMiddleware, CoreUserSession } from '../../types/core.types.js'
-import {
+import type {
+  CorePikkuMiddleware,
+  CoreUserSession,
+} from '../../types/core.types.js'
+import type {
   CoreCLI,
   CLICommandMeta,
   CLIOption,
@@ -19,7 +22,7 @@ import type {
   CreateConfig,
   CreateSingletonServices,
 } from '../../types/core.types.js'
-import { PikkuChannel } from '../channel/channel.types.js'
+import type { PikkuChannel } from '../channel/channel.types.js'
 import {
   PikkuSessionService,
   createMiddlewareSessionWireProps,
@@ -318,6 +321,9 @@ export async function runCLICommand({
         await Promise.resolve(renderer(singletonServices, data, undefined))
       }
     },
+    sendBinary: () => {
+      throw new Error('Binary data is not supported on CLI channels')
+    },
     close: () => {
       if (channel) {
         channel.state = 'closed'
@@ -357,7 +363,11 @@ export async function runCLICommand({
     // Skip if result is undefined (void functions handle their own output)
     if (renderer && result !== undefined) {
       await Promise.resolve(
-        renderer(singletonServices, result, userSession.get())
+        renderer(
+          singletonServices,
+          result,
+          userSession.get() as CoreUserSession | undefined
+        )
       )
     }
 

package/src/wirings/cli/cli.types.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   CorePikkuMiddleware,
   CoreSingletonServices,
   CoreUserSession,
@@ -6,13 +6,13 @@ import {
   MiddlewareMetadata,
   PermissionMetadata,
 } from '../../types/core.types.js'
-import {
+import type {
   CorePikkuFunctionConfig,
   CorePikkuPermission,
   CorePikkuFunction,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
-import { PikkuChannel } from '../channel/channel.types.js'
+import type { PikkuChannel } from '../channel/channel.types.js'
 
 /**
  * CLI option definition

package/src/wirings/cli/command-parser.test.ts

@@ -1,7 +1,7 @@
 import { test, describe } from 'node:test'
 import * as assert from 'assert'
 import { parseCLIArguments, generateCommandHelp } from './command-parser.js'
-import { CLIMeta } from './cli.types.js'
+import type { CLIMeta } from './cli.types.js'
 
 const testMeta: CLIMeta = {
   programs: {

package/src/wirings/cli/command-parser.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   CLIMeta,
   CLIProgramMeta,
   CLICommandMeta,