@pikku/core 0.12.2 → 0.12.4

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

@@ -1,241 +0,0 @@
-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 {
-      pikkuFuncId,
-      middleware: routeInheritedMiddleware,
-      permissions: inheritedPermissions,
-    } = getRouteMeta(channelConfig.name, routingProperty, routerValue)
-
-    // 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,
-      tags: channelConfig.tags,
-      sessionService: userSession,
-      wire: {
-        channel: channelHandler.getChannel(),
-        ...(userSession && createMiddlewareSessionWireProps(userSession)),
-      },
-    })
-  }
-
-  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

@@ -1,120 +0,0 @@
-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 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

@@ -1,166 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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 })
-}