@pikku/core 0.12.4 → 0.12.6

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

@@ -0,0 +1,250 @@
+import type {
+  CoreServices,
+  JSONValue,
+  CoreUserSession,
+} from '../../types/core.types.js'
+import type {
+  BinaryData,
+  ChannelMessageMeta,
+  CoreChannel,
+  PikkuChannelHandler,
+} from './channel.types.js'
+import { pikkuState } from '../../pikku-state.js'
+import { runPikkuFunc } from '../../function/function-runner.js'
+import type { SessionService } from '../../services/user-session-service.js'
+import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js'
+
+const getChannelMeta = (channelName: string) => {
+  return pikkuState(null, 'channel', 'meta')[channelName]
+}
+
+const getRouteMeta = (
+  channelName: string,
+  routingProperty?: string,
+  routerValue?: string
+): ChannelMessageMeta => {
+  const channelMeta = pikkuState(null, 'channel', 'meta')[channelName]
+  if (!channelMeta) {
+    throw new Error(`Channel ${channelName} not found`)
+  }
+  if (!routingProperty) {
+    if (!channelMeta.message) {
+      throw new Error(`Channel ${channelName} has no default message route`)
+    }
+    return channelMeta.message
+  }
+  if (!routerValue) {
+    throw new Error(
+      `Channel ${channelName} requires a router value for ${routingProperty}`
+    )
+  }
+  const route = channelMeta.messageWirings[routingProperty]?.[routerValue]
+  if (!route) {
+    throw new Error(
+      `Channel ${channelName} has no route for ${routingProperty}:${routerValue}`
+    )
+  }
+  return route
+}
+
+const validateAuth = (
+  requiresSession: boolean,
+  session: CoreUserSession | undefined,
+  onMessage: any
+) => {
+  const auth =
+    typeof onMessage === 'function'
+      ? requiresSession
+      : onMessage.auth === undefined
+        ? requiresSession
+        : onMessage.auth
+
+  if (auth && !session) {
+    return false
+  }
+  return true
+}
+
+export const processMessageHandlers = (
+  services: CoreServices,
+  channelConfig: CoreChannel<any, any>,
+  channelHandler: PikkuChannelHandler,
+  userSession?: SessionService<CoreUserSession>
+) => {
+  const logger = services.logger
+  const requiresSession = channelConfig.auth !== false
+
+  const processMessage = async (
+    data: JSONValue,
+    onMessage: any,
+    routingProperty?: string,
+    routerValue?: string
+  ): Promise<unknown> => {
+    if (
+      !validateAuth(
+        requiresSession,
+        userSession?.get() as CoreUserSession | undefined,
+        onMessage
+      )
+    ) {
+      const routeMessage = routingProperty
+        ? `route '${routingProperty}:${routerValue}'`
+        : 'the default message route'
+      logger.error(
+        `Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for ${routeMessage}`
+      )
+      // TODO: Send error message back breaks typescript, but should be implemented somehow
+      channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`)
+      return
+    }
+
+    const routeMeta = getRouteMeta(
+      channelConfig.name,
+      routingProperty,
+      routerValue
+    )
+    const {
+      packageName,
+      middleware: routeInheritedMiddleware,
+      permissions: inheritedPermissions,
+    } = routeMeta
+
+    const pikkuFuncId = routeMeta.pikkuFuncId
+
+    // Get wire middleware: channel-level middleware + message-specific middleware
+    const channelWireMiddleware = channelConfig.middleware || []
+
+    // Check if onMessage is a wrapper object vs direct function config:
+    // - Direct config: onMessage.func is a plain Function
+    // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
+    // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+    const isWrapper =
+      onMessage &&
+      typeof onMessage === 'object' &&
+      'func' in onMessage &&
+      ((typeof onMessage.func === 'object' && 'func' in onMessage.func) ||
+        'middleware' in onMessage)
+    const messageWireMiddleware = isWrapper ? onMessage.middleware || [] : []
+
+    // Combine channel middleware with message middleware (actual functions)
+    // Channel middleware runs first, then message middleware
+    const wireMiddleware = [...channelWireMiddleware, ...messageWireMiddleware]
+
+    // Inherited middleware comes from metadata (tag groups, non-inline wire)
+    const inheritedMiddleware = routeInheritedMiddleware || []
+
+    const wirePermissions = isWrapper ? onMessage.permissions : undefined
+
+    // Create unique cache key that includes routing info to avoid cache collisions
+    // when multiple message handlers use the same function
+    const cacheKey = routingProperty
+      ? `${channelConfig.name}:${routingProperty}:${routerValue}`
+      : `${channelConfig.name}:default`
+
+    const channelMeta = getChannelMeta(channelConfig.name)
+    const wireChannelMiddleware = channelConfig.channelMiddleware || []
+
+    return await runPikkuFunc('channel', cacheKey, pikkuFuncId, {
+      singletonServices: services,
+      data: () => data,
+      inheritedMiddleware,
+      wireMiddleware,
+      inheritedChannelMiddleware: channelMeta?.channelMiddleware,
+      wireChannelMiddleware: wireChannelMiddleware as any,
+      inheritedPermissions,
+      wirePermissions,
+      coerceDataFromSchema: true,
+      tags: channelConfig.tags,
+      sessionService: userSession,
+      wire: {
+        channel: channelHandler.getChannel(),
+        ...(userSession && createMiddlewareSessionWireProps(userSession)),
+      },
+      packageName,
+    })
+  }
+
+  const onMessage = async (rawData: unknown): Promise<unknown> => {
+    let result: unknown
+    let processed = false
+
+    // Route-specific handling
+    if (typeof rawData === 'string' && channelConfig.onMessageWiring) {
+      let messageData: any
+      try {
+        messageData = JSON.parse(rawData)
+      } catch {
+        // Most likely a json error.. ignore
+      }
+
+      if (messageData) {
+        const entries = Object.entries(channelConfig.onMessageWiring)
+        for (const [routingProperty, routes] of entries) {
+          const routerValue = messageData[routingProperty]
+          if (routerValue && routes[routerValue]) {
+            const { [routingProperty]: _, ...data } = messageData
+
+            processed = true
+            result =
+              (await processMessage(
+                data as any,
+                routes[routerValue],
+                routingProperty,
+                routerValue
+              )) || {}
+            ;(result as any)[routingProperty] = routerValue
+            break
+          }
+        }
+
+        // Default handler if no routes matched but json data was parsed
+        if (!processed && channelConfig.onMessage) {
+          processed = true
+          result = await processMessage(messageData, channelConfig.onMessage)
+        }
+      }
+    }
+
+    // Default handler if no routes matched and json data wasn't parsed
+    if (!processed && channelConfig.onMessage) {
+      processed = true
+      result = await processMessage(
+        rawData as JSONValue,
+        channelConfig.onMessage
+      )
+    }
+
+    if (!processed) {
+      logger.error(
+        `No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`
+      )
+      logger.error(`Channel config name: ${channelConfig.name}`)
+    }
+
+    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

@@ -0,0 +1,126 @@
+import type {
+  CoreSingletonServices,
+  MiddlewareMetadata,
+  PikkuWire,
+} from '../../types/core.types.js'
+import type { CorePikkuChannelMiddleware } from './channel.types.js'
+import { pikkuState } from '../../pikku-state.js'
+import { freezeDedupe, getTagGroups } from '../../utils.js'
+
+export const addChannelMiddleware = (
+  tag: string,
+  middleware: CorePikkuChannelMiddleware[],
+  packageName: string | null = null
+): CorePikkuChannelMiddleware[] => {
+  const tagGroups = pikkuState(packageName, 'channelMiddleware', 'tagGroup')
+  tagGroups[tag] = middleware
+  return middleware
+}
+
+const getChannelMiddlewareByName = (
+  name: string
+): CorePikkuChannelMiddleware | undefined => {
+  const store = pikkuState(null, 'misc', 'channelMiddleware')
+  const middleware = store[name]
+  return middleware?.[0]
+}
+
+const channelMiddlewareCache: Record<
+  string,
+  readonly CorePikkuChannelMiddleware[]
+> = {}
+
+export const clearChannelMiddlewareCache = () => {
+  for (const key of Object.keys(channelMiddlewareCache)) {
+    delete channelMiddlewareCache[key]
+  }
+}
+
+export const combineChannelMiddleware = (
+  wireType: string,
+  uid: string,
+  {
+    wireInheritedChannelMiddleware,
+    wireChannelMiddleware,
+    packageName = null,
+  }: {
+    wireInheritedChannelMiddleware?: MiddlewareMetadata[]
+    wireChannelMiddleware?: CorePikkuChannelMiddleware[]
+    packageName?: string | null
+  } = {}
+): readonly CorePikkuChannelMiddleware[] => {
+  const cacheKey = `${wireType}:${uid}`
+  if (channelMiddlewareCache[cacheKey]) {
+    return channelMiddlewareCache[cacheKey]
+  }
+
+  const resolved: CorePikkuChannelMiddleware[] = []
+
+  if (wireInheritedChannelMiddleware) {
+    for (const meta of wireInheritedChannelMiddleware) {
+      if (meta.type === 'tag') {
+        const groups = getTagGroups(
+          pikkuState(packageName, 'channelMiddleware', 'tagGroup'),
+          meta.tag
+        )
+        for (const group of groups) {
+          resolved.push(...group)
+        }
+      } else if (meta.type === 'wire') {
+        const middleware = getChannelMiddlewareByName(meta.name)
+        if (middleware) {
+          resolved.push(middleware)
+        }
+      }
+    }
+  }
+
+  if (wireChannelMiddleware) {
+    resolved.push(...wireChannelMiddleware)
+  }
+
+  channelMiddlewareCache[cacheKey] = freezeDedupe(
+    resolved
+  ) as readonly CorePikkuChannelMiddleware[]
+
+  return channelMiddlewareCache[cacheKey]
+}
+
+export function wrapChannelWithMiddleware<Out>(
+  wire: PikkuWire,
+  services: CoreSingletonServices,
+  middlewares: readonly CorePikkuChannelMiddleware[]
+): PikkuWire {
+  if (middlewares.length === 0 || !wire.channel) return wire
+
+  const channel = wire.channel
+  const originalSend = channel.send.bind(channel)
+
+  const dispatch = async (index: number, event: Out): Promise<void> => {
+    if (index >= middlewares.length) {
+      await originalSend(event)
+      return
+    }
+
+    const middleware = middlewares[index]!
+    await middleware(services, event, async (result: any) => {
+      if (result === null || result === undefined) return
+      if (Array.isArray(result)) {
+        for (const item of result) {
+          await dispatch(index + 1, item)
+        }
+      } else {
+        await dispatch(index + 1, result)
+      }
+    })
+  }
+
+  return {
+    ...wire,
+    channel: {
+      ...channel,
+      send: ((data: Out) => dispatch(0, data)) as typeof channel.send,
+      sendBinary: channel.sendBinary,
+    },
+  }
+}

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

@@ -0,0 +1,166 @@
+import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js'
+import { addFunction } from '../../function/function-runner.js'
+import type { CorePikkuPermission } from '../../function/functions.types.js'
+import { pikkuState, getSingletonServices } from '../../pikku-state.js'
+import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js'
+import type { SessionService } from '../../services/user-session-service.js'
+import type { CorePikkuMiddleware } from '../../types/core.types.js'
+import { httpRouter } from '../http/routers/http-router.js'
+import type {
+  ChannelMeta,
+  CoreChannel,
+  RunChannelOptions,
+  RunChannelParams,
+} from './channel.types.js'
+
+/**
+ * Adds a channel and registers all functions referenced in it using the
+ * function names already stored in the channel metadata
+ */
+export const wireChannel = <
+  In,
+  Channel extends string,
+  PikkuPermission extends CorePikkuPermission<In>,
+  PikkuMiddleware extends CorePikkuMiddleware,
+  ChannelFunction,
+>(
+  channel: CoreChannel<
+    In,
+    Channel,
+    PikkuPermission,
+    PikkuMiddleware,
+    ChannelFunction
+  >
+) => {
+  // Get the channel metadata
+  const channelsMeta = pikkuState(null, 'channel', 'meta')
+  const channelMeta = channelsMeta[channel.name]
+  if (!channelMeta) {
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for channel '${channel.name}'`
+    )
+  }
+
+  pikkuState(null, 'channel', 'channels').set(channel.name, channel as any)
+
+  // Register onConnect function if provided
+  if (channel.onConnect && channelMeta.connect) {
+    addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect as any)
+  }
+
+  // Register onDisconnect function if provided
+  if (channel.onDisconnect && channelMeta.disconnect) {
+    addFunction(channelMeta.disconnect.pikkuFuncId, channel.onDisconnect as any)
+  }
+
+  // Register onMessage function if provided
+  if (channel.onMessage && channelMeta.message?.pikkuFuncId) {
+    addFunction(
+      channelMeta.message.pikkuFuncId,
+      (channel.onMessage as any).func instanceof Function
+        ? channel.onMessage
+        : (channel.onMessage as any).func
+    )
+  }
+
+  // Register functions in onMessageWiring
+  if (channel.onMessageWiring && channelMeta.messageWirings) {
+    // Iterate through each channel in onMessageWiring
+    Object.entries(channel.onMessageWiring).forEach(([channelKey, wirings]) => {
+      const channelWirings = channelMeta.messageWirings[channelKey]
+      if (!channelWirings) return
+
+      // Iterate through each wiring in the channel
+      Object.entries(wirings).forEach(([wiringKey, handler]) => {
+        const wiringMeta = channelWirings[wiringKey]
+        if (!wiringMeta) return
+
+        // Register the function using the pikku name from metadata
+        // It could be a FuncConfig or a wiring override with a funcConfig
+        addFunction(
+          wiringMeta.pikkuFuncId,
+          (handler as any).func instanceof Function
+            ? handler
+            : (handler as any).func
+        )
+      })
+    })
+  }
+
+  // Store the channel configuration
+  pikkuState(null, 'channel', 'channels').set(channel.name, channel as any)
+}
+
+const getMatchingChannelConfig = (path: string) => {
+  const matchedPath = httpRouter.match('get', path)
+  if (!matchedPath) {
+    return null
+  }
+
+  const meta = pikkuState(null, 'channel', 'meta')
+  const channelMeta = Object.values(meta).find(
+    (channelConfig) => channelConfig.route === matchedPath.route
+  )
+  if (!channelMeta) {
+    return null
+  }
+
+  const channels = pikkuState(null, 'channel', 'channels')
+  const channelConfig = channels.get(channelMeta.name)
+  if (!channelConfig) {
+    return null
+  }
+
+  return {
+    matchedPath,
+    params: matchedPath.params,
+    channelConfig,
+    schemaName: channelMeta.input,
+    meta: channelMeta,
+  }
+}
+
+export const openChannel = async ({
+  route,
+  coerceDataFromSchema = true,
+  request,
+}: Pick<CoreChannel<unknown, string>, 'route'> &
+  RunChannelParams<unknown> & {
+    userSession: SessionService<any>
+  } & RunChannelOptions): Promise<{
+  openingData: unknown
+  channelConfig: CoreChannel<unknown, any>
+  meta: ChannelMeta
+}> => {
+  const singletonServices = getSingletonServices()
+  const matchingChannel = getMatchingChannelConfig(route)
+  if (!matchingChannel) {
+    singletonServices.logger.info(`Channel not found: ${route}`)
+    throw new NotFoundError(`Channel not found: ${route}`)
+  }
+
+  const { params, channelConfig, schemaName, meta } = matchingChannel
+
+  const requiresSession = channelConfig.auth !== false
+  request?.setParams(params)
+
+  singletonServices.logger.info(
+    `Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`
+  )
+
+  let openingData: any | undefined
+  if (request) {
+    openingData = await request.data()
+    if (coerceDataFromSchema && schemaName) {
+      coerceTopLevelDataFromSchema(schemaName, openingData)
+    }
+    await validateSchema(
+      singletonServices.logger,
+      singletonServices.schema,
+      schemaName,
+      openingData
+    )
+  }
+
+  return { openingData, channelConfig, meta }
+}

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

@@ -0,0 +1,29 @@
+import type { CoreUserSession } from '../../types/core.types.js'
+
+export type Channel<ChannelType = unknown, OpeningData = unknown> = {
+  channelId: string
+  channelName: string
+  channelObject?: ChannelType
+  openingData?: OpeningData
+}
+
+export abstract class ChannelStore<
+  ChannelType = unknown,
+  OpeningData = unknown,
+  UserSession extends CoreUserSession = CoreUserSession,
+  TypedChannel = Channel<ChannelType, OpeningData>,
+> {
+  public abstract addChannel(
+    channel: Channel<ChannelType, OpeningData>
+  ): Promise<void> | void
+  public abstract removeChannels(channelId: string[]): Promise<void> | void
+  public abstract setUserSession(
+    channelId: string,
+    userSession: UserSession | null
+  ): Promise<void> | void
+  public abstract getChannelAndSession(
+    channelId: string
+  ):
+    | Promise<TypedChannel & { session: UserSession }>
+    | (TypedChannel & { session: UserSession })
+}