@pikku/core 0.12.106 → 0.12.111

package/src/wirings/channel/local/local-eventhub-service.test.ts

@@ -1,77 +0,0 @@
-import * as assert from 'assert'
-import { test } from 'node:test'
-import type { PikkuChannelHandler } from '../channel.types.js'
-import { LocalEventHubService } from './local-eventhub-service.js'
-
-class MockChannelHandler implements PikkuChannelHandler {
-  private channelId: string
-
-  constructor(channelId: string) {
-    this.channelId = channelId
-  }
-
-  getChannel() {
-    return { channelId: this.channelId } as any
-  }
-
-  send(data: unknown, isBinary?: boolean) {
-    console.log(`Sent to ${this.channelId}:`, { data, isBinary })
-  }
-}
-
-test('LocalEventHubService: subscribe and unsubscribe', () => {
-  const eventHub = new LocalEventHubService()
-
-  eventHub.subscribe('topic1', 'channel1')
-  assert.strictEqual(eventHub['subscriptions'].get('topic1')!.size, 1)
-
-  eventHub.unsubscribe('topic1', 'channel1')
-  assert.strictEqual(eventHub['subscriptions'].has('topic1'), false)
-})
-
-test('LocalEventHubService: publish messages', () => {
-  const eventHub = new LocalEventHubService()
-
-  const channel1 = new MockChannelHandler('channel1')
-  const channel2 = new MockChannelHandler('channel2')
-  eventHub.onChannelOpened(channel1)
-  eventHub.onChannelOpened(channel2)
-
-  eventHub.subscribe('topic1', 'channel1')
-  eventHub.subscribe('topic1', 'channel2')
-
-  let sendCallCount = 0
-  channel1.send = () => {
-    sendCallCount++
-  }
-  channel2.send = () => {
-    sendCallCount++
-  }
-
-  eventHub.publish('topic1', 'channel1', { message: 'Hello!' })
-
-  assert.strictEqual(sendCallCount, 1)
-})
-
-test('LocalEventHubService: onChannelOpened and onChannelClosed', () => {
-  const eventHub = new LocalEventHubService()
-
-  const channel1 = new MockChannelHandler('channel1')
-  eventHub.onChannelOpened(channel1)
-  assert.strictEqual(eventHub['channels'].has('channel1'), true)
-
-  eventHub.onChannelClosed('channel1')
-  assert.strictEqual(eventHub['channels'].has('channel1'), false)
-})
-
-test('LocalEventHubService: clean up empty topics on channel close', () => {
-  const eventHub = new LocalEventHubService()
-
-  const channel1 = new MockChannelHandler('channel1')
-  eventHub.onChannelOpened(channel1)
-  eventHub.subscribe('topic1', 'channel1')
-
-  eventHub.onChannelClosed('channel1')
-
-  assert.strictEqual(eventHub['subscriptions'].has('topic1'), false)
-})

package/src/wirings/channel/local/local-eventhub-service.ts

@@ -1,69 +0,0 @@
-import type { PikkuChannelHandler } from '../channel.types.js'
-import type { EventHubService } from '../eventhub-service.js'
-
-export class LocalEventHubService<
-  Data extends Record<string, any> = {},
-> implements EventHubService<Data> {
-  private channels = new Map<string, PikkuChannelHandler>()
-  private subscriptions: Map<keyof Data, Set<string>> = new Map()
-
-  public subscribe<T extends keyof Data>(
-    topic: T,
-    channelId: string
-  ): void | Promise<void> {
-    if (!this.subscriptions.has(topic)) {
-      this.subscriptions.set(topic, new Set())
-    }
-    this.subscriptions.get(topic)!.add(channelId)
-  }
-
-  public unsubscribe<T extends keyof Data>(
-    topic: T,
-    channelId: string
-  ): void | Promise<void> {
-    const topicSubscriptions = this.subscriptions.get(topic)
-    if (topicSubscriptions) {
-      topicSubscriptions.delete(channelId)
-      if (topicSubscriptions.size === 0) {
-        this.subscriptions.delete(topic)
-      }
-    }
-  }
-
-  public publish<T extends keyof Data>(
-    topic: T,
-    channelId: string | null,
-    data: Data[T],
-    isBinary?: boolean
-  ): void | Promise<void> {
-    const subscribedChannelIds = this.subscriptions.get(topic)
-    if (!subscribedChannelIds) {
-      return
-    }
-    for (const toChannelId of subscribedChannelIds) {
-      if (channelId === toChannelId) continue
-      const channel = this.channels.get(toChannelId)
-      if (channel) {
-        try {
-          channel.send(data, isBinary)
-        } catch {
-          this.onChannelClosed(toChannelId)
-        }
-      }
-    }
-  }
-
-  public onChannelOpened(channelHandler: PikkuChannelHandler): void {
-    this.channels.set(channelHandler.getChannel().channelId, channelHandler)
-  }
-
-  public onChannelClosed(channelId: string): void {
-    for (const [topic, channelIds] of this.subscriptions.entries()) {
-      channelIds.delete(channelId)
-      if (channelIds.size === 0) {
-        this.subscriptions.delete(topic)
-      }
-    }
-    this.channels.delete(channelId)
-  }
-}

package/src/wirings/channel/log-channels.ts

@@ -1,16 +0,0 @@
-import { pikkuState } from '../../pikku-state.js'
-import type { Logger } from '../../services/index.js'
-
-export const logChannels = (logger: Logger) => {
-  const channels = pikkuState(null, 'channel', 'channels')
-  if (channels.size === 0) {
-    logger.info('No channels added')
-    return
-  }
-
-  let scheduledChannels = 'Channels:'
-  channels.forEach((channel) => {
-    scheduledChannels += `\n\t- ${channel.name} at ${channel.route}`
-  })
-  logger.info(scheduledChannels)
-}

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

@@ -1,135 +0,0 @@
-import { test, beforeEach, describe } from 'node:test'
-import * as assert from 'node:assert/strict'
-import { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js'
-import { setSingletonServices } from '../../pikku-state.js'
-import { CHANNEL_RPC_RESPONSE } from './channel-rpc.js'
-import type { ChannelRPCError } from './channel-rpc.js'
-import { handleChannelRPCResponse } from './channel-host-rpc.js'
-
-// A concrete implementation of the abstract class for testing
-class TestChannelHandler extends PikkuAbstractChannelHandler<
-  { param: string },
-  { msg: string }
-> {
-  public sent: unknown[] = []
-
-  public async send(message: { msg: string }, isBinary = false): Promise<void> {
-    this.sent.push(message)
-  }
-
-  public sendBinary(_data: ArrayBuffer | Uint8Array): void {}
-}
-
-let handler: TestChannelHandler
-
-/**
- * Arguments are checked before the request goes out, so the write lands a tick
- * after the call rather than in the same one.
- */
-const sent = () => new Promise((resolve) => setImmediate(resolve))
-
-beforeEach(() => {
-  handler = new TestChannelHandler('test-channel-id', 'channel-name', {
-    param: 'testParam',
-  })
-})
-
-test('getChannel should return a channel with initial state', () => {
-  const channel = handler.getChannel()
-  assert.equal(channel.channelId, 'test-channel-id', 'Channel ID should match')
-  assert.equal(channel.state, 'initial', 'Initial state should be "initial"')
-  assert.deepEqual(
-    channel.openingData,
-    { param: 'testParam' },
-    'Opening data should be accessible'
-  )
-})
-
-test('open should change channel state to open', () => {
-  handler.open()
-  const channel = handler.getChannel()
-  assert.equal(
-    channel.state,
-    'open',
-    'State should be "open" after calling open()'
-  )
-})
-
-test('close should change channel state to closed', () => {
-  handler.close()
-  const channel = handler.getChannel()
-  assert.equal(
-    channel.state,
-    'closed',
-    'State should be "closed" after calling close()'
-  )
-})
-
-/**
- * Every channel gets `remote` — reverse RPC is a property of having an open
- * connection, not of any one wiring having asked for it.
- */
-describe('channel.remote', () => {
-  beforeEach(() => {
-    // The transport builds a result validator from the singletons. Nothing
-    // here declares an RPC contract, so validation finds no schema and passes.
-    setSingletonServices({ logger: console } as never)
-  })
-
-  test('writes a request to the peer and resolves when it answers', async () => {
-    const channel = handler.getChannel()
-    const call = channel.remote('localCheckout', { cwd: '/repo' })
-    await sent()
-
-    const request = handler.sent[0] as {
-      action: string
-      id: string
-      funcName: string
-      data: unknown
-    }
-    assert.equal(request.funcName, 'localCheckout')
-    assert.deepEqual(request.data, { cwd: '/repo' })
-
-    handleChannelRPCResponse(channel.channelId, {
-      action: CHANNEL_RPC_RESPONSE,
-      id: request.id,
-      ok: true,
-      result: { sha: 'deadbeef' },
-    })
-
-    assert.deepEqual(await call, { sha: 'deadbeef' })
-    handler.close()
-  })
-
-  test('a closing channel fails what the peer still owed an answer to', async () => {
-    const channel = handler.getChannel()
-    const call = channel.remote('localCheckout')
-
-    handler.close()
-
-    await assert.rejects(call, (e: ChannelRPCError) => {
-      assert.equal(e.reason, 'closed')
-      return true
-    })
-  })
-
-  test('a second connection does not inherit the first transport', async () => {
-    const first = handler.getChannel()
-    const call = first.remote('localCheckout')
-    handler.close()
-    await assert.rejects(call)
-
-    const reconnected = new TestChannelHandler(
-      'test-channel-id',
-      'channel-name',
-      { param: 'testParam' }
-    )
-    const second = reconnected.getChannel().remote('localCheckout')
-    await sent()
-    // Ids restart, which is only safe because the closed transport was
-    // forgotten rather than reused.
-    assert.equal((reconnected.sent[0] as { id: string }).id, '1')
-    reconnected.close()
-    await assert.rejects(second)
-  })
-})

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

@@ -1,60 +0,0 @@
-import type {
-  BinaryData,
-  PikkuChannel,
-  PikkuChannelHandler,
-} from './channel.types.js'
-import { channelRemote, releaseChannelHostRPC } from './channel-host-rpc.js'
-
-export abstract class PikkuAbstractChannelHandler<
-  OpeningData = unknown,
-  Out = unknown,
-> implements PikkuChannelHandler<OpeningData, Out> {
-  protected channel?: PikkuChannel<OpeningData, Out>
-
-  constructor(
-    public channelId: string,
-    public channelName: string,
-    protected openingData: OpeningData
-  ) {}
-
-  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) {
-      let channelState: unknown
-      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',
-        setState: (s) => {
-          channelState = s
-        },
-        // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
-        getState: () => channelState as never,
-        clearState: () => {
-          channelState = undefined
-        },
-        remote: (funcName: string, data?: unknown) =>
-          channelRemote(this.getChannel(), funcName, data),
-      }
-    }
-    return this.channel
-  }
-
-  public open(): void {
-    this.getChannel().state = 'open'
-  }
-
-  public close(): Promise<void> | void {
-    this.getChannel().state = 'closed'
-    // Fails anything the departing peer still owed an answer to. Not awaited:
-    // `close` is on every runtime's synchronous path, and nothing here can fail
-    // in a way a closing channel could act on.
-    void releaseChannelHostRPC(this.channelId)
-  }
-}

package/src/wirings/channel/serverless/index.ts

@@ -1,6 +0,0 @@
-export {
-  runChannelConnect,
-  runChannelDisconnect,
-  runChannelMessage,
-} from './serverless-channel-runner.js'
-export type { RunServerlessChannelParams } from './serverless-channel-runner.js'

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

@@ -1,328 +0,0 @@
-import type {
-  CoreUserSession,
-  PikkuRawWire,
-  WireServices,
-} from '../../../types/core.types.js'
-import { closeWireServices } from '../../../utils.js'
-import { processMessageHandlers } from '../channel-handler.js'
-import { openChannel } from '../channel-runner.js'
-import type {
-  CoreChannel,
-  RunChannelOptions,
-  RunChannelParams,
-  PikkuChannelHandlerFactory,
-} from '../channel.types.js'
-import { createHTTPWire } from '../../http/http-runner.js'
-import type { ChannelStore } from '../channel-store.js'
-import { handleHTTPError } from '../../../handle-error.js'
-import {
-  PikkuSessionService,
-  createMiddlewareSessionWireProps,
-} from '../../../services/user-session-service.js'
-import {
-  getSingletonServices,
-  getCreateWireServices,
-  pikkuState,
-} from '../../../pikku-state.js'
-import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js'
-import type { PikkuHTTP } from '../../http/http.types.js'
-import { runChannelLifecycleWithMiddleware } from '../channel-common.js'
-
-export interface RunServerlessChannelParams<
-  ChannelData,
-> extends RunChannelParams<ChannelData> {
-  channelStore: ChannelStore
-  channelHandlerFactory: PikkuChannelHandlerFactory
-  channelObject?: unknown
-}
-
-const getVariablesForChannel = ({
-  channelId,
-  channelName,
-  channelHandlerFactory,
-  openingData,
-}: {
-  channelId: string
-  channelName: string
-  channelHandlerFactory: PikkuChannelHandlerFactory
-  openingData?: unknown
-}) => {
-  const channels = pikkuState(null, 'channel', 'channels')
-  const channelConfig = channels.get(channelName)
-  const channelsMeta = pikkuState(null, 'channel', 'meta')
-  const meta = channelsMeta[channelName]
-  if (!channelConfig) {
-    throw new Error(`Channel not found: ${channelName}`)
-  }
-  if (!meta) {
-    throw new Error(`Channel meta not found: ${channelName}`)
-  }
-  const channelHandler = channelHandlerFactory(
-    channelId,
-    channelConfig.name,
-    openingData
-  )
-  return {
-    channelConfig,
-    channelHandler,
-    channel: channelHandler.getChannel(),
-    meta,
-  }
-}
-
-export const runChannelConnect = async ({
-  channelId,
-  channelObject,
-  request,
-  response,
-  route,
-  channelStore,
-  channelHandlerFactory,
-  coerceDataFromSchema = true,
-  logWarningsForStatusCodes = [],
-  respondWith404 = true,
-  bubbleErrors = false,
-}: Pick<CoreChannel<unknown, any>, 'route'> &
-  RunChannelOptions &
-  RunServerlessChannelParams<unknown>) => {
-  const singletonServices = getSingletonServices()
-  const createWireServices = getCreateWireServices()
-  let wireServices: WireServices | undefined
-
-  let http: PikkuHTTP | undefined
-  if (request instanceof Request) {
-    http = createHTTPWire(new PikkuFetchHTTPRequest(request), response)
-  }
-
-  const userSession = new PikkuSessionService(singletonServices.sessionStore)
-
-  const { channelConfig, openingData, meta } = await openChannel({
-    channelId,
-    request,
-    route,
-    coerceDataFromSchema,
-    userSession,
-  })
-
-  try {
-    await channelStore.addChannel({
-      channelId,
-      channelName: channelConfig.name,
-      openingData,
-      channelObject,
-    })
-    const { channel } = getVariablesForChannel({
-      channelId,
-      channelHandlerFactory,
-      channelName: channelConfig.name,
-    })
-    channel.setState = (state) => channelStore.setState(channelId, state)
-    // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
-    channel.getState = () => channelStore.getState(channelId) as never
-    channel.clearState = () => channelStore.clearState(channelId)
-
-    const wire: PikkuRawWire = {
-      channel,
-      ...createMiddlewareSessionWireProps(userSession),
-    }
-
-    if (createWireServices) {
-      wireServices = await createWireServices(singletonServices, wire)
-    }
-
-    const services = {
-      ...singletonServices,
-      ...wireServices,
-    }
-
-    if (channelConfig.onConnect && meta.connect) {
-      await runChannelLifecycleWithMiddleware({
-        channelConfig,
-        meta: meta.connect,
-        lifecycleConfig: channelConfig.onConnect,
-        lifecycleType: 'connect',
-        services,
-        channel,
-        data: openingData,
-        channelMiddlewareMeta: meta.channelMiddleware,
-        userSession,
-      })
-    }
-
-    const pikkuUserId = userSession.getPikkuUserId()
-    if (pikkuUserId) {
-      await channelStore.setPikkuUserId(channelId, pikkuUserId)
-    }
-
-    http?.response?.status(101)
-  } catch (e: any) {
-    handleHTTPError(
-      e,
-      http,
-      channelId,
-      singletonServices.logger,
-      logWarningsForStatusCodes,
-      respondWith404,
-      bubbleErrors
-    )
-  } finally {
-    if (wireServices) {
-      await closeWireServices(singletonServices.logger, wireServices)
-    }
-  }
-}
-
-export const runChannelDisconnect = async ({
-  channelId,
-  channelStore,
-  channelHandlerFactory,
-}: RunServerlessChannelParams<unknown>): Promise<void> => {
-  const singletonServices = getSingletonServices()
-  const createWireServices = getCreateWireServices()
-  let wireServices: WireServices | undefined
-
-  let channelData
-  try {
-    channelData = await channelStore.getChannel(channelId)
-  } catch {
-    singletonServices.logger.info(
-      `Channel ${channelId} not found during disconnect - already cleaned up`
-    )
-    return
-  }
-
-  const { openingData, channelName, pikkuUserId } = channelData
-  const { channel, channelConfig, meta } = getVariablesForChannel({
-    channelId,
-    channelHandlerFactory,
-    openingData,
-    channelName,
-  })
-  channel.setState = (state) => channelStore.setState(channelId, state)
-  // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
-  channel.getState = () => channelStore.getState(channelId) as never
-  channel.clearState = () => channelStore.clearState(channelId)
-
-  const userSession = new PikkuSessionService<CoreUserSession>(
-    singletonServices.sessionStore
-  )
-  if (pikkuUserId) {
-    userSession.setPikkuUserId(pikkuUserId)
-    const session = await singletonServices.sessionStore?.get(pikkuUserId)
-    if (session) {
-      userSession.setInitial(session)
-    }
-  }
-
-  const wire: PikkuRawWire = {
-    channel,
-    ...createMiddlewareSessionWireProps(userSession),
-  }
-
-  if (createWireServices) {
-    wireServices = await createWireServices(singletonServices, wire)
-  }
-
-  const services = {
-    ...singletonServices,
-    ...wireServices,
-  }
-
-  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.message || e}`
-      )
-    }
-  }
-  await channelStore.removeChannels([channel.channelId])
-  if (wireServices) {
-    await closeWireServices(singletonServices.logger, wireServices)
-  }
-}
-
-export const runChannelMessage = async (
-  {
-    channelId,
-    channelStore,
-    channelHandlerFactory,
-  }: RunServerlessChannelParams<unknown>,
-  data: unknown
-): Promise<unknown> => {
-  const singletonServices = getSingletonServices()
-  const createWireServices = getCreateWireServices()
-  let wireServices: WireServices | undefined
-  const { openingData, channelName, pikkuUserId } =
-    await channelStore.getChannel(channelId)
-
-  const { channel, channelHandler, channelConfig } = getVariablesForChannel({
-    channelId,
-    channelHandlerFactory,
-    openingData,
-    channelName,
-  })
-  channel.setState = (state) => channelStore.setState(channelId, state)
-  // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
-  channel.getState = () => channelStore.getState(channelId) as never
-  channel.clearState = () => channelStore.clearState(channelId)
-
-  const userSession = new PikkuSessionService<CoreUserSession>(
-    singletonServices.sessionStore
-  )
-  if (pikkuUserId) {
-    userSession.setPikkuUserId(pikkuUserId)
-    const session = await singletonServices.sessionStore?.get(pikkuUserId)
-    if (session) {
-      userSession.setInitial(session)
-    }
-  }
-
-  const wire: PikkuRawWire = {
-    channel,
-    ...createMiddlewareSessionWireProps(userSession),
-  }
-
-  if (createWireServices) {
-    wireServices = await createWireServices(singletonServices, wire)
-  }
-
-  const services = {
-    ...singletonServices,
-    ...wireServices,
-  }
-
-  let response: unknown
-  try {
-    const { onMessage } = processMessageHandlers(
-      services,
-      channelConfig,
-      channelHandler,
-      userSession
-    )
-    response = await onMessage(data)
-  } catch (e: any) {
-    singletonServices.logger.error(
-      `Error processing message: ${e.message || e}`
-    )
-    return {
-      error: e.message || 'Unknown error',
-      errorName: e.constructor?.name,
-    }
-  } finally {
-    if (wireServices) {
-      await closeWireServices(singletonServices.logger, wireServices)
-    }
-  }
-  return response
-}