@pikku/core 0.12.107 → 0.12.111

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

@@ -1,98 +0,0 @@
-import type { Logger } from '../../../services/logger.js'
-import type { BinaryData } from '../channel.types.js'
-import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js'
-
-export class PikkuLocalChannelHandler<
-  OpeningData = unknown,
-  Out = unknown,
-> extends PikkuAbstractChannelHandler<OpeningData, Out> {
-  private onMessageCallback?: (message: unknown) => void
-  private onBinaryMessageCallback?: (data: BinaryData) => void
-  private openCallBack?: () => Promise<void> | void
-  private closeCallbacks: (() => Promise<void> | void)[] = []
-  private sendCallback?: (message: Out, isBinary?: boolean) => void
-  private sendBinaryCallback?: (data: BinaryData) => void
-  private logger?: Logger
-
-  constructor(
-    channelId: string,
-    channelName: string,
-    openingData: OpeningData,
-    logger?: Logger
-  ) {
-    super(channelId, channelName, openingData)
-    this.logger = logger
-  }
-
-  public registerOnOpen(callback: () => Promise<void> | void): void {
-    this.openCallBack = callback
-  }
-
-  public async open(): Promise<void> {
-    this.getChannel().state = 'open'
-    if (this.openCallBack) {
-      await this.openCallBack()
-    }
-  }
-
-  public registerOnMessage(callback: (data: any) => Promise<unknown>): void {
-    this.onMessageCallback = callback
-  }
-
-  public async message(data: unknown): Promise<unknown> {
-    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: () => Promise<void> | void): void {
-    this.closeCallbacks.push(callback)
-  }
-
-  public async close(): Promise<void> {
-    if (this.getChannel().state === 'closed') {
-      return
-    }
-    super.close()
-    const results = await Promise.allSettled(
-      this.closeCallbacks.map((cb) => cb())
-    )
-    for (const result of results) {
-      if (result.status === 'rejected') {
-        this.logger?.error('Error in channel close callback:', result.reason)
-      }
-    }
-  }
-
-  public registerOnSend(send: (message: Out) => void) {
-    this.sendCallback = send
-  }
-
-  public send(message: Out, isBinary?: boolean): void {
-    if (!this.sendCallback) {
-      throw new Error('No send callback registered')
-    }
-    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.test.ts

@@ -1,339 +0,0 @@
-import { test, beforeEach, afterEach } from 'node:test'
-import * as assert from 'node:assert/strict'
-import { runLocalChannel } from './local-channel-runner.js'
-import { pikkuState, resetPikkuState } from '../../../pikku-state.js'
-import { wireChannel } from '../channel-runner.js'
-import { addFunction } from '../../../function/function-runner.js'
-import { addHTTPMiddleware } from '../../http/http-runner.js'
-import type {
-  HTTPMethod,
-  PikkuHTTPRequest,
-  PikkuHTTPResponse,
-  PikkuQuery,
-} from '../../http/http.types.js'
-import type { SerializeOptions } from 'cookie'
-import { httpRouter } from '../../http/routers/http-router.js'
-import { pikkuMiddleware } from '../../../middleware/middleware-factories.js'
-const mockLogger = {
-  info: () => {},
-  error: () => {},
-  warn: () => {},
-  debug: () => {},
-}
-
-const mockSingletonServices = {
-  logger: mockLogger,
-} as any
-
-export class PikkuMockRequest implements PikkuHTTPRequest {
-  private _params: Record<string, string | string[] | undefined> = {}
-
-  constructor(
-    private _route: string,
-    private _method: HTTPMethod
-  ) {}
-
-  method(): HTTPMethod {
-    return this._method
-  }
-  path(): string {
-    return this._route
-  }
-  json(): Promise<unknown> {
-    throw new Error('Method not implemented.')
-  }
-  arrayBuffer(): Promise<ArrayBuffer> {
-    throw new Error('Method not implemented.')
-  }
-  header(headerName: string): string | null {
-    throw new Error('Method not implemented.')
-  }
-  cookie(name?: string): string | null {
-    throw new Error('Method not implemented.')
-  }
-  params(): Partial<Record<string, string | string[]>> {
-    return this._params
-  }
-  setParams(params: Record<string, string | string[] | undefined>): void {
-    this._params = params
-  }
-  query(): PikkuQuery {
-    throw new Error('Method not implemented.')
-  }
-  public async data() {
-    return { test: 'data' }
-  }
-}
-
-export class PikkuMockResponse implements PikkuHTTPResponse {
-  public _status: number = 200
-
-  public get statusCode(): number {
-    return this._status
-  }
-
-  status(code: number): this {
-    this._status = code
-    return this
-  }
-
-  cookie(name: string, value: string | null, options: SerializeOptions): this {
-    throw new Error('Method not implemented.')
-  }
-  header(name: string, value: string | string[]): this {
-    throw new Error('Method not implemented.')
-  }
-  arrayBuffer(data: XMLHttpRequestBodyInit): this {
-    throw new Error('Method not implemented.')
-  }
-  json(data: unknown): this {
-    return this
-  }
-  redirect(location: string, status?: number): this {
-    throw new Error('Method not implemented.')
-  }
-}
-
-const mockCreateWireServices = async () => ({
-  wireServiceMock: true,
-})
-
-beforeEach(() => {
-  resetPikkuState()
-  httpRouter.reset()
-  pikkuState(null, 'package', 'singletonServices', mockSingletonServices as any)
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: mockCreateWireServices,
-  } as any)
-})
-
-afterEach(() => {
-  resetPikkuState()
-  httpRouter.reset()
-})
-
-test('runChannel should return undefined and 404 if no matching channel is found', async () => {
-  const mockResponse = new PikkuMockResponse()
-
-  const result = await runLocalChannel({
-    channelId: 'test-channel-id',
-    request: new PikkuMockRequest('/non-existent-channel', 'get'),
-    response: mockResponse,
-  })
-
-  assert.equal(
-    result,
-    undefined,
-    'Should return undefined if no channel matches'
-  )
-  assert.equal(mockResponse._status, 404, 'Should set response status to 404')
-})
-
-test('runChannel should return a channel handler if channel matches and no auth required', async () => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', mockSingletonServices as any)
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: mockCreateWireServices,
-  } as any)
-
-  pikkuState(null, 'channel', 'meta', {
-    test: {
-      name: 'test',
-      route: '/test-channel',
-    },
-  } as any)
-  wireChannel({
-    name: 'test',
-    route: '/test-channel',
-    auth: false,
-  })
-
-  httpRouter.initialize()
-
-  const result = await runLocalChannel({
-    channelId: 'test-channel-id',
-    request: new PikkuMockRequest('/test-channel', 'get'),
-    response: new PikkuMockResponse(),
-    route: '/test-channel',
-  })
-
-  assert.ok(result, 'Should return a PikkuChannelHandler instance')
-
-  result.open()
-})
-
-test('runChannel should close wire services once when channel closes', async () => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', mockSingletonServices as any)
-  let closeCount = 0
-
-  pikkuState(null, 'channel', 'meta', {
-    test: {
-      name: 'test',
-      route: '/test-channel',
-    },
-  } as any)
-  wireChannel({
-    name: 'test',
-    route: '/test-channel',
-    auth: false,
-  })
-
-  httpRouter.initialize()
-
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: async () => ({
-      tracked: {
-        close: async () => {
-          closeCount += 1
-        },
-      },
-    }),
-  } as any)
-
-  const result = await runLocalChannel({
-    channelId: 'test-channel-id',
-    request: new PikkuMockRequest('/test-channel', 'get'),
-    response: new PikkuMockResponse(),
-    route: '/test-channel',
-  })
-
-  assert.ok(result)
-  assert.equal(closeCount, 0)
-
-  result.close()
-  await new Promise((resolve) => setTimeout(resolve, 0))
-  assert.equal(closeCount, 1)
-
-  result.close()
-  await new Promise((resolve) => setTimeout(resolve, 0))
-  assert.equal(closeCount, 1)
-})
-
-test('runChannel should run HTTP middleware on websocket upgrade and establish session', async () => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', mockSingletonServices as any)
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: mockCreateWireServices,
-  } as any)
-
-  addHTTPMiddleware(
-    '*',
-    [
-      pikkuMiddleware(async (_services, { setSession }, next) => {
-        setSession?.({ userId: 'user-1' } as any)
-        await next()
-      }),
-    ],
-    null
-  )
-
-  pikkuState(null, 'channel', 'meta', {
-    test: {
-      name: 'test',
-      route: '/test-channel',
-      messageWirings: {
-        action: {
-          ping: {
-            pikkuFuncId: 'test:ping',
-          },
-        },
-      },
-    },
-  } as any)
-  wireChannel({
-    name: 'test',
-    route: '/test-channel',
-    onMessageWiring: {
-      action: {
-        ping: {
-          func: async (_services, data) => data,
-        },
-      },
-    },
-  } as any)
-
-  httpRouter.initialize()
-
-  const result = await runLocalChannel({
-    channelId: 'test-channel-id',
-    request: new PikkuMockRequest('/test-channel', 'get'),
-    response: new PikkuMockResponse(),
-    route: '/test-channel',
-  })
-
-  assert.ok(result)
-  let sent: unknown
-  result.registerOnSend((message) => {
-    sent = message
-  })
-  await result.message(JSON.stringify({ action: 'ping' }))
-  assert.deepEqual(sent, { action: 'ping' })
-})
-
-test('a message handler that returns nothing does not attempt to send', async () => {
-  // The connect path already guards this; the message path did not, so a handler
-  // with nothing to say produced `send requires a non-empty message` on every
-  // message. Gateway websockets hit it every time — their generated message
-  // handler returns undefined by design — which is why a chat gateway could
-  // accept a connection and never deliver anything to its handler.
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', mockSingletonServices as any)
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: mockCreateWireServices,
-  } as any)
-
-  const sent: unknown[] = []
-  let handled = 0
-
-  pikkuState(null, 'channel', 'meta', {
-    quiet: {
-      name: 'quiet',
-      route: '/quiet-channel',
-      message: { pikkuFuncId: 'quietMessage' },
-      messageWirings: {},
-    },
-  } as any)
-  pikkuState(null, 'function', 'meta')['quietMessage'] = {
-    pikkuFuncId: 'quietMessage',
-    inputSchemaName: null,
-    outputSchemaName: null,
-    sessionless: true,
-  } as any
-  const quietMessage = {
-    auth: false,
-    func: async () => {
-      handled++
-      return undefined
-    },
-  }
-  wireChannel({
-    name: 'quiet',
-    route: '/quiet-channel',
-    auth: false,
-    onMessage: quietMessage as any,
-  } as any)
-
-  httpRouter.initialize()
-
-  const handler = await runLocalChannel({
-    channelId: 'quiet-channel-id',
-    request: new PikkuMockRequest('/quiet-channel', 'get'),
-    response: new PikkuMockResponse(),
-    route: '/quiet-channel',
-  })
-  assert.ok(handler)
-  handler.registerOnSend(async (message: unknown) => {
-    sent.push(message)
-  })
-  handler.open()
-
-  await handler.message(JSON.stringify({ text: 'hello' }))
-
-  assert.equal(handled, 1, 'the handler should have run')
-  assert.deepEqual(
-    sent,
-    [],
-    'nothing should have been sent for an empty result'
-  )
-})

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

@@ -1,271 +0,0 @@
-import { openChannel } from '../channel-runner.js'
-import { createHTTPWire } from '../../http/http-runner.js'
-import { closeWireServices } from '../../../utils.js'
-import { processMessageHandlers } from '../channel-handler.js'
-import type { CoreChannel, RunChannelOptions } from '../channel.types.js'
-import { PikkuLocalChannelHandler } from './local-channel-handler.js'
-import type {
-  PikkuRawWire,
-  PikkuWire,
-  WireServices,
-} from '../../../types/core.types.js'
-import { isProduction } from '../../../env.js'
-import { getErrorResponse } from '../../../errors/error-handler.js'
-import { handleHTTPError } from '../../../handle-error.js'
-import {
-  PikkuSessionService,
-  createMiddlewareSessionWireProps,
-} from '../../../services/user-session-service.js'
-import { combineMiddleware, runMiddleware } from '../../../middleware-runner.js'
-import type {
-  PikkuHTTP,
-  PikkuHTTPRequest,
-  PikkuHTTPResponse,
-} from '../../http/http.types.js'
-import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
-import {
-  getSingletonServices,
-  getCreateWireServices,
-  pikkuState,
-} from '../../../pikku-state.js'
-
-const runUpgradeMiddleware = async (
-  singletonServices: ReturnType<typeof getSingletonServices>,
-  request: PikkuHTTPRequest,
-  response: PikkuHTTPResponse | undefined,
-  userSession: PikkuSessionService<any>
-) => {
-  const http = createHTTPWire(request, response)
-  const httpGroups = pikkuState(null, 'middleware', 'httpGroup')
-  const wireInheritedMiddleware = httpGroups['*']
-    ? [{ type: 'http' as const, route: '*' }]
-    : undefined
-  const middleware = combineMiddleware('channel', 'upgrade', {
-    wireInheritedMiddleware,
-  })
-
-  if (middleware.length > 0) {
-    await runMiddleware(
-      singletonServices,
-      {
-        http,
-        ...createMiddlewareSessionWireProps(userSession),
-      } as unknown as PikkuWire,
-      middleware
-    )
-  }
-
-  return http
-}
-
-export const runLocalChannel = async ({
-  channelId,
-  request,
-  response,
-  route,
-  skipUserSession = false,
-  respondWith404 = true,
-  coerceDataFromSchema = true,
-  logWarningsForStatusCodes = [],
-  bubbleErrors = false,
-}: Partial<Pick<CoreChannel<unknown, any>, 'route'>> &
-  RunChannelOptions & {
-    channelId: string
-    request?: PikkuHTTPRequest
-    response?: PikkuHTTPResponse
-  }): Promise<PikkuLocalChannelHandler | void> => {
-  const singletonServices = getSingletonServices()
-  const createWireServices = getCreateWireServices()
-  let wireServices: WireServices<typeof singletonServices> | undefined
-  let closedWireServices = false
-
-  let channelHandler: PikkuLocalChannelHandler | undefined
-  const userSession = new PikkuSessionService(singletonServices.sessionStore)
-
-  let http: PikkuHTTP | undefined
-  let openingData, channelConfig, meta
-  try {
-    if (request) {
-      http = await runUpgradeMiddleware(
-        singletonServices,
-        request,
-        response,
-        userSession
-      )
-      route = request.path()
-    }
-
-    ;({ openingData, channelConfig, meta } = await openChannel({
-      channelId,
-      respondWith404,
-      request,
-      response,
-      route,
-      skipUserSession,
-      coerceDataFromSchema,
-      userSession,
-    }))
-  } catch (e) {
-    handleHTTPError(
-      e,
-      http,
-      channelId,
-      singletonServices.logger,
-      logWarningsForStatusCodes,
-      respondWith404,
-      bubbleErrors
-    )
-    return
-  }
-
-  const main = async () => {
-    try {
-      channelHandler = new PikkuLocalChannelHandler(
-        channelId,
-        channelConfig.name,
-        openingData,
-        singletonServices.logger
-      )
-      const channel = channelHandler.getChannel()
-      const wire: PikkuRawWire = {
-        channel,
-        ...createMiddlewareSessionWireProps(userSession),
-      }
-
-      if (createWireServices) {
-        wireServices = await createWireServices(singletonServices, wire)
-      }
-
-      const closeServices = async () => {
-        if (!wireServices || closedWireServices) {
-          return
-        }
-        closedWireServices = true
-        await closeWireServices(singletonServices.logger, wireServices)
-      }
-
-      const services = { ...singletonServices, ...wireServices }
-
-      channelHandler.registerOnOpen(async () => {
-        if (channelConfig.onConnect && meta.connect) {
-          try {
-            const result = await runChannelLifecycleWithMiddleware({
-              channelConfig,
-              meta: meta.connect,
-              lifecycleConfig: channelConfig.onConnect,
-              lifecycleType: 'connect',
-              services,
-              channel,
-              data: openingData,
-              channelMiddlewareMeta: meta.channelMiddleware,
-              userSession,
-            })
-            if (result !== undefined) {
-              await channel.send(result)
-            }
-          } catch (e: any) {
-            singletonServices.logger.error(`Error handling onConnect: ${e}`)
-            const errorResponse = getErrorResponse(e)
-            channel.send({
-              error:
-                errorResponse?.message ??
-                (isProduction() ? 'Internal server error' : e.message),
-              ...(!isProduction() && { errorName: e.constructor?.name }),
-            })
-          }
-        }
-      })
-
-      channelHandler.registerOnClose(async () => {
-        if (channelConfig.onDisconnect && meta.disconnect) {
-          try {
-            await runChannelLifecycleWithMiddleware({
-              channelConfig,
-              meta: meta.disconnect,
-              lifecycleConfig: channelConfig.onDisconnect,
-              lifecycleType: 'disconnect',
-              services,
-              channel,
-              channelMiddlewareMeta: meta.channelMiddleware,
-              userSession,
-            })
-          } catch (e: any) {
-            singletonServices.logger.error(`Error handling onDisconnect: ${e}`)
-            const errorResponse = getErrorResponse(e)
-            channel.send({
-              error:
-                errorResponse?.message ??
-                (isProduction() ? 'Internal server error' : e.message),
-              ...(!isProduction() && { errorName: e.constructor?.name }),
-            })
-          }
-        }
-
-        await closeServices()
-      })
-
-      const { onMessage, onBinaryMessage } = processMessageHandlers(
-        services,
-        channelConfig,
-        channelHandler,
-        userSession
-      )
-      channelHandler.registerOnMessage(async (data) => {
-        try {
-          const result = await onMessage(data)
-          // Guarded exactly as the connect path above is. A handler with nothing
-          // to say is normal — a gateway websocket's generated message handler
-          // always returns undefined — and sending that raised `send requires a
-          // non-empty message`, which surfaced as a channel that accepted a
-          // connection and then silently delivered nothing.
-          if (result !== undefined) {
-            await channel.send(result)
-          }
-        } catch (e: any) {
-          singletonServices.logger.error(e)
-          const errorResponse = getErrorResponse(e)
-          channel.send({
-            error:
-              errorResponse?.message ??
-              (isProduction() ? 'Internal server error' : e.message),
-            ...(!isProduction() && { 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,
-        http,
-        channelId,
-        singletonServices.logger,
-        logWarningsForStatusCodes,
-        respondWith404,
-        bubbleErrors
-      )
-    } finally {
-      if (!channelHandler && wireServices && !closedWireServices) {
-        closedWireServices = true
-        await closeWireServices(singletonServices.logger, wireServices)
-      }
-    }
-  }
-
-  await main()
-
-  return channelHandler
-}