@pikku/core 0.12.1 → 0.12.3

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

@@ -4,6 +4,7 @@ import type {
   CoreUserSession,
 } from '../../types/core.types.js'
 import type {
+  BinaryData,
   ChannelMessageMeta,
   CoreChannel,
   PikkuChannelHandler,
@@ -97,11 +98,18 @@ export const processMessageHandlers = (
       return
     }
 
+    const routeMeta = getRouteMeta(
+      channelConfig.name,
+      routingProperty,
+      routerValue
+    )
     const {
-      pikkuFuncId,
+      packageName,
       middleware: routeInheritedMiddleware,
       permissions: inheritedPermissions,
-    } = getRouteMeta(channelConfig.name, routingProperty, routerValue)
+    } = routeMeta
+
+    const pikkuFuncId = routeMeta.pikkuFuncId
 
     // Get wire middleware: channel-level middleware + message-specific middleware
     const channelWireMiddleware = channelConfig.middleware || []
@@ -145,16 +153,18 @@ export const processMessageHandlers = (
       wireChannelMiddleware: wireChannelMiddleware as any,
       inheritedPermissions,
       wirePermissions,
+      coerceDataFromSchema: true,
       tags: channelConfig.tags,
       sessionService: userSession,
       wire: {
         channel: channelHandler.getChannel(),
         ...(userSession && createMiddlewareSessionWireProps(userSession)),
       },
+      packageName,
     })
   }
 
-  return async (rawData): Promise<unknown> => {
+  const onMessage = async (rawData: unknown): Promise<unknown> => {
     let result: unknown
     let processed = false
 
@@ -198,7 +208,10 @@ export const processMessageHandlers = (
     // Default handler if no routes matched and json data wasn't parsed
     if (!processed && channelConfig.onMessage) {
       processed = true
-      result = await processMessage(rawData, channelConfig.onMessage)
+      result = await processMessage(
+        rawData as JSONValue,
+        channelConfig.onMessage
+      )
     }
 
     if (!processed) {
@@ -210,4 +223,28 @@ export const processMessageHandlers = (
 
     return result
   }
+
+  const onBinaryMessage = channelConfig.onBinaryMessage
+    ? async (data: BinaryData): Promise<BinaryData | void> => {
+        if (
+          !validateAuth(
+            requiresSession,
+            userSession?.get() as CoreUserSession | undefined,
+            channelConfig
+          )
+        ) {
+          logger.error(
+            `Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for binary message`
+          )
+          return
+        }
+        return channelConfig.onBinaryMessage!(
+          services,
+          data,
+          channelHandler.getChannel()
+        )
+      }
+    : undefined
+
+  return { onMessage, onBinaryMessage }
 }

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

@@ -114,6 +114,7 @@ export function wrapChannelWithMiddleware<Out>(
     channel: {
       ...channel,
       send: ((data: Out) => dispatch(0, data)) as typeof channel.send,
+      sendBinary: channel.sendBinary,
     },
   }
 }

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

@@ -1,4 +1,3 @@
-import type { PikkuError } from '../../errors/error-handler.js'
 import type {
   HTTPFunctionMetaInputTypes,
   PikkuHTTPRequest,
@@ -10,6 +9,8 @@ import type {
   PermissionMetadata,
 } from '../../types/core.types.js'
 
+export type BinaryData = ArrayBuffer | Uint8Array
+
 export type CorePikkuChannelMiddleware<Services = any, Event = unknown> = (
   services: Services,
   event: Event,
@@ -45,6 +46,7 @@ export type RunChannelParams<ChannelData> = {
 
 export interface ChannelMessageMeta {
   pikkuFuncId: string
+  packageName?: string
   summary?: string
   description?: string
   errors?: string[]
@@ -64,6 +66,7 @@ export interface ChannelMeta {
   disconnect: ChannelMessageMeta | null
   message: ChannelMessageMeta | null
   messageWirings: Record<string, Record<string, ChannelMessageMeta>>
+  binary?: boolean | null
   summary?: string
   description?: string
   errors?: string[]
@@ -132,12 +135,12 @@ export type CoreChannel<
   >
   permissions?: CorePermissionGroup<PikkuPermission>
   auth?: boolean
-  docs?: Partial<{
-    description: string
-    response: string
-    errors: Array<typeof PikkuError>
-    tags: string[]
-  }>
+  binary?: boolean | null
+  onBinaryMessage?: (
+    services: any,
+    data: BinaryData,
+    channel: PikkuChannel<ChannelData, any>
+  ) => Promise<BinaryData | void> | BinaryData | void
   tags?: string[]
 }
 
@@ -149,6 +152,7 @@ export interface PikkuChannel<OpeningData, out Out> {
   openingData: OpeningData
   // The data to send. This will fail is the stream has been closed.
   send(data: Out, isBinary?: boolean): Promise<void> | void
+  sendBinary(data: BinaryData): Promise<void> | void
   // This will close the channel.
   close(): Promise<void> | void
   // The current state of the channel
@@ -157,6 +161,7 @@ export interface PikkuChannel<OpeningData, out Out> {
 
 export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {
   send(message: Out, isBinary?: boolean): Promise<void> | void
+  sendBinary(data: BinaryData): Promise<void> | void
   getChannel(): PikkuChannel<OpeningData, Out>
 }
 

package/src/wirings/channel/index.ts

@@ -11,6 +11,7 @@ export { ChannelStore } from './channel-store.js'
 export type { Channel } from './channel-store.js'
 export { EventHubStore } from './eventhub-store.js'
 export type {
+  BinaryData,
   ChannelsMeta,
   CoreChannel,
   CorePikkuChannelMiddleware,

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

@@ -1,3 +1,4 @@
+import type { BinaryData } from '../channel.types.js'
 import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js'
 
 export class PikkuLocalChannelHandler<
@@ -5,9 +6,11 @@ export class PikkuLocalChannelHandler<
   Out = unknown,
 > extends PikkuAbstractChannelHandler<OpeningData, Out> {
   private onMessageCallback?: (message: unknown) => void
+  private onBinaryMessageCallback?: (data: BinaryData) => void
   private openCallBack?: () => void
-  private closeCallback?: () => void
+  private closeCallbacks: (() => void)[] = []
   private sendCallback?: (message: Out, isBinary?: boolean) => void
+  private sendBinaryCallback?: (data: BinaryData) => void
 
   public registerOnOpen(callback: () => void): void {
     this.openCallBack = callback
@@ -28,8 +31,20 @@ export class PikkuLocalChannelHandler<
     return this.onMessageCallback?.(data)
   }
 
+  public registerOnBinaryMessage(
+    callback: (
+      data: BinaryData
+    ) => Promise<BinaryData | void> | BinaryData | void
+  ): void {
+    this.onBinaryMessageCallback = callback
+  }
+
+  public async binaryMessage(data: BinaryData): Promise<BinaryData | void> {
+    return this.onBinaryMessageCallback?.(data)
+  }
+
   public registerOnClose(callback: () => void): void {
-    this.closeCallback = callback
+    this.closeCallbacks.push(callback)
   }
 
   public close() {
@@ -37,7 +52,9 @@ export class PikkuLocalChannelHandler<
       return
     }
     super.close()
-    this.closeCallback?.()
+    for (const cb of this.closeCallbacks) {
+      cb()
+    }
   }
 
   public registerOnSend(send: (message: Out) => void) {
@@ -50,4 +67,15 @@ export class PikkuLocalChannelHandler<
     }
     return this.sendCallback?.(message, isBinary)
   }
+
+  public registerOnSendBinary(send: (data: BinaryData) => void) {
+    this.sendBinaryCallback = send
+  }
+
+  public sendBinary(data: BinaryData): void {
+    if (!this.sendBinaryCallback) {
+      throw new Error('No sendBinary callback registered')
+    }
+    this.sendBinaryCallback(data)
+  }
 }

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

@@ -119,9 +119,12 @@ export const runLocalChannel = async ({
             if (result !== undefined) {
               await channel.send(result)
             }
-          } catch (e) {
+          } catch (e: any) {
             singletonServices.logger.error(`Error handling onConnect: ${e}`)
-            channel.send({ error: e.message || 'Unknown error' })
+            channel.send({
+              error: e.message || 'Unknown error',
+              errorName: e.constructor?.name,
+            })
           }
         }
       })
@@ -138,16 +141,19 @@ export const runLocalChannel = async ({
               channel,
               channelMiddlewareMeta: meta.channelMiddleware,
             })
-          } catch (e) {
+          } catch (e: any) {
             singletonServices.logger.error(`Error handling onDisconnect: ${e}`)
-            channel.send({ error: e.message || 'Unknown error' })
+            channel.send({
+              error: e.message || 'Unknown error',
+              errorName: e.constructor?.name,
+            })
           }
         }
 
         await closeServices()
       })
 
-      const onMessage = processMessageHandlers(
+      const { onMessage, onBinaryMessage } = processMessageHandlers(
         services,
         channelConfig as any,
         channelHandler,
@@ -157,11 +163,29 @@ export const runLocalChannel = async ({
         try {
           const result = await onMessage(data)
           await channel.send(result)
-        } catch (e) {
-          singletonServices.logger.error(`Error handling message: ${e.message}`)
-          channel.send({ error: e.message || 'Unknown error' })
+        } catch (e: any) {
+          singletonServices.logger.error(e)
+          channel.send({
+            error: e.message || 'Unknown error',
+            errorName: e.constructor?.name,
+          })
+          setTimeout(() => channel.close(), 200)
         }
       })
+      if (onBinaryMessage) {
+        channelHandler.registerOnBinaryMessage(async (data) => {
+          try {
+            const result = await onBinaryMessage(data)
+            if (result) {
+              await channel.sendBinary(result)
+            }
+          } catch (e) {
+            singletonServices.logger.error(
+              `Error handling binary message: ${e.message}`
+            )
+          }
+        })
+      }
     } catch (e: any) {
       handleHTTPError(
         e,

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

@@ -265,7 +265,7 @@ export const runChannelMessage = async (
 
   let response: unknown
   try {
-    const onMessage = processMessageHandlers(
+    const { onMessage } = processMessageHandlers(
       services,
       channelConfig,
       channelHandler,
@@ -276,7 +276,10 @@ export const runChannelMessage = async (
     singletonServices.logger.error(
       `Error processing message: ${e.message || e}`
     )
-    return { error: e.message || 'Unknown error' }
+    return {
+      error: e.message || 'Unknown error',
+      errorName: e.constructor?.name,
+    }
   } finally {
     if (wireServices) {
       await closeWireServices(singletonServices.logger, wireServices)

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

@@ -218,7 +218,9 @@ function pluckCLIData(
   const funcMeta = pikkuState(null, 'function', 'meta')[funcName]
   const schemaName = funcMeta?.inputSchemaName
   const schema = schemaName
-    ? pikkuState(null, 'misc', 'schemas').get(schemaName)
+    ? pikkuState(funcMeta?.packageName ?? null, 'misc', 'schemas').get(
+        schemaName
+      )
     : null
 
   if (schema && schema.properties) {
@@ -226,7 +228,13 @@ function pluckCLIData(
     const result: Record<string, any> = {}
     for (const key of Object.keys(schema.properties)) {
       if (key in mergedData) {
-        result[key] = mergedData[key]
+        let value = mergedData[key]
+        // CLI passes all values as strings — coerce to array when schema expects one
+        const propSchema = schema.properties[key]
+        if (propSchema?.type === 'array' && !Array.isArray(value)) {
+          value = typeof value === 'string' ? value.split(',') : [value]
+        }
+        result[key] = value
       } else if (availableOptions[key]?.default !== undefined) {
         // Apply default if not provided
         result[key] = availableOptions[key].default
@@ -321,6 +329,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'
@@ -351,9 +362,11 @@ export async function runCLICommand({
       wireMiddleware: allWireMiddleware,
       inheritedPermissions: currentCommand.permissions,
       wirePermissions: undefined,
+      coerceDataFromSchema: true,
       tags: programData?.tags,
       wire,
       sessionService: userSession,
+      packageName: currentCommand.packageName,
     })
 
     // Apply renderer one final time with the final output (if renderer exists)

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

@@ -70,6 +70,7 @@ export interface CLIProgramState {
 export interface CLICommandMeta {
   parameters?: string
   pikkuFuncId: string
+  packageName?: string
   positionals: CLIPositional[]
   options: Record<string, CLIOption>
   renderName?: string