@pikku/core 0.12.107 → 0.12.112

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

@@ -1,102 +0,0 @@
-import type { CorePikkuChannelMiddleware } from './channel.types.js'
-import type {
-  CoreSingletonServices,
-  PikkuRawWire,
-  PikkuWire,
-} from '../../types/core.types.js'
-import type {
-  CorePikkuMiddleware,
-  MiddlewareMetadata,
-} from '../../middleware/middleware.types.js'
-import type { CoreChannel, ChannelMessageMeta } from './channel.types.js'
-import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
-import { runPikkuFunc } from '../../function/function-runner.js'
-import {
-  type PikkuSessionService,
-  createMiddlewareSessionWireProps,
-} from '../../services/user-session-service.js'
-import {
-  combineChannelMiddleware,
-  wrapChannelWithMiddleware,
-} from './channel-middleware-runner.js'
-
-export const runChannelLifecycleWithMiddleware = async ({
-  channelConfig,
-  meta,
-  lifecycleConfig,
-  lifecycleType,
-  services,
-  channel,
-  data,
-  channelMiddlewareMeta,
-  userSession,
-}: {
-  channelConfig: CoreChannel<unknown, any>
-  meta: ChannelMessageMeta
-  lifecycleConfig: any
-  lifecycleType: 'connect' | 'disconnect'
-  services: CoreSingletonServices
-  channel: any
-  data?: unknown
-  channelMiddlewareMeta?: MiddlewareMetadata[]
-  /**
-   * Established while the socket was upgrading, so `onConnect` can tell who
-   * just connected.
-   */
-  userSession?: PikkuSessionService<any>
-}): Promise<unknown> => {
-  const lifecycleMiddleware =
-    typeof lifecycleConfig === 'object' && 'middleware' in lifecycleConfig
-      ? (lifecycleConfig.middleware as CorePikkuMiddleware[]) || []
-      : []
-
-  const allMiddleware = combineMiddleware(
-    'channel',
-    `${channelConfig.name}:${lifecycleType}`,
-    {
-      wireInheritedMiddleware: meta.middleware,
-      wireMiddleware: lifecycleMiddleware,
-    }
-  )
-
-  const allChannelMiddleware = combineChannelMiddleware(
-    'channel',
-    `${channelConfig.name}:${lifecycleType}:cm`,
-    {
-      wireInheritedChannelMiddleware: channelMiddlewareMeta,
-      // knowledge: questions/channel-middleware-accepts-bare-factories-that-nothing-resolves.md
-      wireChannelMiddleware:
-        channelConfig.channelMiddleware as CorePikkuChannelMiddleware[],
-    }
-  )
-
-  let wire: PikkuRawWire = {
-    channel,
-    ...(userSession ? createMiddlewareSessionWireProps(userSession) : {}),
-  }
-  if (allChannelMiddleware.length > 0) {
-    wire = wrapChannelWithMiddleware(wire, services, allChannelMiddleware)
-  }
-
-  const runLifecycle = async () => {
-    return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
-      singletonServices: services,
-      data: () => data,
-      wire,
-      sessionService: userSession,
-      tags: meta.tags ?? [],
-      packageName: meta.packageName ?? null,
-    })
-  }
-
-  if (allMiddleware.length > 0) {
-    return await runMiddleware(
-      services,
-      wire as unknown as PikkuWire,
-      allMiddleware,
-      runLifecycle
-    )
-  } else {
-    return await runLifecycle()
-  }
-}

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

@@ -1,72 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { wireChannel } from './channel-runner.js'
-
-const registeredFunc = (funcId: string) =>
-  pikkuState(null, 'function', 'functions').get(funcId)
-
-const wire = (channel: any) => {
-  resetPikkuState()
-  pikkuState(null, 'channel', 'meta', {
-    shapes: {
-      name: 'shapes',
-      route: '/shapes',
-      input: null,
-      connect: { pikkuFuncId: 'shapes__connect' },
-      disconnect: { pikkuFuncId: 'shapes__disconnect' },
-      message: { pikkuFuncId: 'shapes__message' },
-      messageWirings: {},
-    },
-  } as any)
-  wireChannel({ name: 'shapes', route: '/shapes', ...channel })
-}
-
-/**
- * knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
- */
-describe('every channel handler shape registers a callable function config', () => {
-  const handler = async () => undefined
-
-  test('a direct function config registers as-is', () => {
-    wire({ onConnect: { func: handler } })
-
-    assert.equal(typeof registeredFunc('shapes__connect')?.func, 'function')
-  })
-
-  test('a wrapper around a function config registers the inner config', () => {
-    wire({ onConnect: { func: { func: handler }, middleware: [] } })
-
-    // Registering the wrapper itself leaves `.func` an object, and the function
-    // runner calls `.func(...)` — that is a TypeError at connect time.
-    assert.equal(
-      typeof registeredFunc('shapes__connect')?.func,
-      'function',
-      'the wrapper was registered instead of the config it wraps'
-    )
-  })
-
-  test('onDisconnect unwraps the same way', () => {
-    wire({ onDisconnect: { func: { func: handler }, middleware: [] } })
-
-    assert.equal(typeof registeredFunc('shapes__disconnect')?.func, 'function')
-  })
-
-  test('onMessage unwraps the same way', () => {
-    wire({ onMessage: { func: { func: handler } } })
-
-    assert.equal(typeof registeredFunc('shapes__message')?.func, 'function')
-  })
-
-  test('a simple wrapper — a function plus sibling middleware — stays whole', () => {
-    wire({ onConnect: { func: handler, middleware: [] } })
-
-    const registered = registeredFunc('shapes__connect')
-    assert.equal(typeof registered?.func, 'function')
-    assert.ok(
-      'middleware' in (registered as object),
-      'the sibling middleware must survive registration'
-    )
-  })
-})

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

@@ -1,322 +0,0 @@
-import { beforeEach, describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { addFunction } from '../../function/function-runner.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { processMessageHandlers } from './channel-handler.js'
-import { getChannelHostRPC, releaseChannelHostRPC } from './channel-host-rpc.js'
-import { CHANNEL_RPC_RESPONSE } from './channel-rpc.js'
-
-const createLogger = () => {
-  const errors: string[] = []
-  return {
-    errors,
-    logger: {
-      debug: () => {},
-      info: () => {},
-      warn: () => {},
-      error: (...args: unknown[]) => {
-        errors.push(args.map((arg) => String(arg)).join(' '))
-      },
-    },
-  }
-}
-
-const createChannelHandler = () => {
-  const sent: unknown[] = []
-  const channel = {
-    channelId: 'channel-1',
-    openingData: {},
-    state: 'open' as const,
-    send: (message: unknown) => {
-      sent.push(message)
-    },
-    sendBinary: () => {},
-    close: () => {},
-    setState: () => {},
-    getState: () => undefined,
-    clearState: () => {},
-  }
-
-  return {
-    sent,
-    handler: {
-      send: (message: unknown) => channel.send(message),
-      sendBinary: () => {},
-      getChannel: () => channel,
-    },
-  }
-}
-
-const registerFunction = (
-  funcName: string,
-  func: (services: any, data: any, wire: any) => Promise<unknown> | unknown
-) => {
-  addFunction(funcName, { func } as never)
-  pikkuState(null, 'function', 'meta')[funcName] = {
-    name: funcName,
-    sessionless: true,
-    permissions: [],
-  } as never
-}
-
-beforeEach(() => {
-  resetPikkuState()
-})
-
-describe('processMessageHandlers', () => {
-  test('routes json messages using onMessageWiring and appends the routing key to the result', async () => {
-    const { logger } = createLogger()
-    const { handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: null,
-      messageWirings: {
-        kind: {
-          ping: {
-            pikkuFuncId: 'pingFunc',
-            packageName: null,
-          },
-        },
-      },
-    } as never
-    registerFunction('pingFunc', async (_services, data) => ({
-      reply: `pong:${data.value}`,
-    }))
-
-    const { onMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        auth: false,
-        onMessageWiring: {
-          kind: {
-            ping: {
-              func: { func: async () => ({ ok: true }) } as never,
-            },
-          },
-        },
-      } as never,
-      handler as never
-    )
-
-    const result = await onMessage('{"kind":"ping","value":"hello"}')
-
-    assert.deepEqual(result, {
-      reply: 'pong:hello',
-      kind: 'ping',
-    })
-  })
-
-  test('falls back to the default handler for parsed json with no matching route', async () => {
-    const { logger } = createLogger()
-    const { handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: {
-        pikkuFuncId: 'defaultFunc',
-        packageName: null,
-      },
-      messageWirings: {
-        kind: {
-          ping: {
-            pikkuFuncId: 'pingFunc',
-            packageName: null,
-          },
-        },
-      },
-    } as never
-    registerFunction('defaultFunc', async (_services, data) => ({
-      seen: data,
-    }))
-
-    const { onMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        auth: false,
-        onMessage: { func: async () => ({ ok: true }) } as never,
-        onMessageWiring: {
-          kind: {
-            ping: {
-              func: { func: async () => ({ ok: true }) } as never,
-            },
-          },
-        },
-      } as never,
-      handler as never
-    )
-
-    const result = await onMessage('{"kind":"unknown","value":"hello"}')
-
-    assert.deepEqual(result, {
-      seen: { kind: 'unknown', value: 'hello' },
-    })
-  })
-
-  test('uses wrapper auth for default messages and sends unauthorized errors without a session', async () => {
-    const { errors, logger } = createLogger()
-    const { sent, handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: {
-        pikkuFuncId: 'defaultFunc',
-        packageName: null,
-      },
-      messageWirings: {},
-    } as never
-    registerFunction('defaultFunc', async () => ({ ok: true }))
-
-    const { onMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        auth: false,
-        onMessage: {
-          auth: true,
-          func: { func: async () => ({ ok: true }) } as never,
-        },
-      } as never,
-      handler as never
-    )
-
-    const result = await onMessage('hello')
-
-    assert.equal(result, undefined)
-    assert.deepEqual(sent, ['Unauthorized for the default message route'])
-    assert.match(
-      errors[0] || '',
-      /requires a session for the default message route/
-    )
-  })
-
-  test('logs when no message handler can process the payload', async () => {
-    const { errors, logger } = createLogger()
-    const { handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: null,
-      messageWirings: {},
-    } as never
-
-    const { onMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        auth: false,
-      } as never,
-      handler as never
-    )
-
-    const result = await onMessage({ raw: true })
-
-    assert.equal(result, undefined)
-    assert.match(
-      errors[0] || '',
-      /No handler found for message in channel chat/
-    )
-    assert.match(errors[1] || '', /Channel config name: chat/)
-  })
-
-  test('takes a reverse-RPC answer off the socket before routing', async () => {
-    const { errors, logger } = createLogger()
-    const { sent, handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: { pikkuFuncId: 'defaultFunc', packageName: null },
-      messageWirings: {},
-    } as never
-    registerFunction('defaultFunc', async () => ({ ok: true }))
-
-    const { onMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        auth: false,
-        onMessage: { func: async () => ({ ok: true }) } as never,
-      } as never,
-      handler as never
-    )
-
-    const transport = getChannelHostRPC(handler.getChannel() as never)
-    const call = transport.invoke('localCheckout', {})
-    const request = sent[0] as { id: string }
-
-    const result = await onMessage(
-      JSON.stringify({
-        action: CHANNEL_RPC_RESPONSE,
-        id: request.id,
-        ok: true,
-        result: { sha: 'deadbeef' },
-      })
-    )
-
-    assert.deepEqual(await call, { sha: 'deadbeef' })
-    // The channel declares no route for replies and its default handler is
-    // never reached — the answer belongs to the waiting caller, not the app.
-    assert.equal(result, undefined)
-    assert.deepEqual(errors, [])
-
-    await releaseChannelHostRPC(handler.getChannel().channelId)
-  })
-
-  test('blocks binary messages when a session is required and missing', async () => {
-    const { errors, logger } = createLogger()
-    const { handler } = createChannelHandler()
-
-    pikkuState(null, 'channel', 'meta').chat = {
-      name: 'chat',
-      route: '/chat',
-      input: null,
-      connect: null,
-      disconnect: null,
-      message: null,
-      messageWirings: {},
-    } as never
-
-    const { onBinaryMessage } = processMessageHandlers(
-      { logger } as never,
-      {
-        name: 'chat',
-        route: '/chat',
-        onBinaryMessage: async () => new Uint8Array([1, 2, 3]),
-      } as never,
-      handler as never
-    )
-
-    const result = await onBinaryMessage?.(new Uint8Array([1, 2, 3]))
-
-    assert.equal(result, undefined)
-    assert.match(errors[0] || '', /requires a session for binary message/)
-  })
-})