@pikku/core 0.7.0 → 0.7.2

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

@@ -0,0 +1,157 @@
+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 { addChannel } from '../channel-runner.js'
+import {
+  HTTPMethod,
+  PikkuHTTPRequest,
+  PikkuHTTPResponse,
+  PikkuQuery,
+} from '../../http/http.types.js'
+import { SerializeOptions } from 'cookie'
+
+/**
+ * Minimal stubs for dependencies that runChannel expects.
+ * In a real test setup, you may provide more comprehensive mocks
+ * or refactor your code to allow dependency injection.
+ */
+const mockLogger = {
+  info: () => {},
+  error: () => {},
+  warn: () => {},
+  debug: () => {},
+}
+
+const mockSingletonServices = {
+  logger: mockLogger,
+} as any
+
+// Mock request and response objects
+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 | undefined
+
+  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 {
+    // We don't need to implement this for our test
+    return this
+  }
+  redirect(location: string, status?: number): this {
+    throw new Error('Method not implemented.')
+  }
+}
+
+const mockCreateSessionServices = async () => ({ sessionServiceMock: true })
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+afterEach(() => {
+  resetPikkuState()
+})
+
+test('runChannel should return undefined and 404 if no matching channel is found', async () => {
+  const mockResponse = new PikkuMockResponse()
+
+  const result = await runLocalChannel({
+    singletonServices: mockSingletonServices,
+    channelId: 'test-channel-id',
+    request: new PikkuMockRequest('/non-existent-channel', 'get'),
+    response: mockResponse,
+    createSessionServices: mockCreateSessionServices,
+  })
+
+  assert.equal(
+    result,
+    undefined,
+    'Should return undefined if no channel matches'
+  )
+  assert.equal(mockResponse._status, 404, 'Should set response status to 404')
+  // assert.equal(mockResponse._ended, true, 'Should end the response')
+})
+
+test('runChannel should return a channel handler if channel matches and no auth required', async () => {
+  resetPikkuState()
+
+  pikkuState('channel', 'meta', {
+    test: {
+      name: 'test',
+      route: '/test-channel',
+    },
+  } as any)
+  addChannel({
+    name: 'test',
+    route: '/test-channel',
+    auth: false,
+  })
+
+  const result = await runLocalChannel({
+    singletonServices: mockSingletonServices,
+    channelId: 'test-channel-id',
+    request: new PikkuMockRequest('/test-channel', 'get'),
+    response: new PikkuMockResponse(),
+    route: '/test-channel',
+    createSessionServices: mockCreateSessionServices,
+  })
+
+  assert.ok(result, 'Should return a PikkuChannelHandler instance')
+
+  // Simulate opening the channel
+  result.open()
+
+  // TODO: Test that the opened channel works
+})

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

@@ -0,0 +1,139 @@
+import { openChannel } from '../channel-runner.js'
+import { createHTTPInteraction } from '../../http/http-runner.js'
+import { closeSessionServices } from '../../utils.js'
+import { processMessageHandlers } from '../channel-handler.js'
+import {
+  CoreAPIChannel,
+  RunChannelOptions,
+  RunChannelParams,
+} from '../channel.types.js'
+import { PikkuLocalChannelHandler } from './local-channel-handler.js'
+import { SessionServices } from '../../types/core.types.js'
+import { handleError } from '../../handle-error.js'
+import { runMiddleware } from '../../middleware-runner.js'
+import { PikkuUserSessionService } from '../../services/user-session-service.js'
+import { PikkuHTTP } from '../../http/http.types.js'
+import { runPikkuFuncDirectly } from '../../function/function-runner.js'
+
+export const runLocalChannel = async ({
+  singletonServices,
+  channelId,
+  request,
+  response,
+  route,
+  createSessionServices,
+  skipUserSession = false,
+  respondWith404 = true,
+  coerceDataFromSchema = true,
+  logWarningsForStatusCodes = [],
+  bubbleErrors = false,
+}: Partial<Pick<CoreAPIChannel<unknown, any>, 'route'>> &
+  RunChannelOptions &
+  RunChannelParams<unknown>): Promise<PikkuLocalChannelHandler | void> => {
+  let sessionServices: SessionServices<typeof singletonServices> | undefined
+
+  let channelHandler: PikkuLocalChannelHandler | undefined
+  const userSession = new PikkuUserSessionService()
+
+  let http: PikkuHTTP | undefined
+  if (request) {
+    http = createHTTPInteraction(request, response)
+    route = http?.request?.path()
+  }
+
+  const main = async () => {
+    try {
+      const { openingData, channelConfig, meta } = await openChannel({
+        channelId,
+        createSessionServices,
+        respondWith404,
+        request,
+        response,
+        route,
+        singletonServices,
+        skipUserSession,
+        coerceDataFromSchema,
+        userSession,
+      })
+
+      channelHandler = new PikkuLocalChannelHandler(
+        channelId,
+        channelConfig.name,
+        openingData
+      )
+      const channel = channelHandler.getChannel()
+      const session = await userSession.get()
+      if (createSessionServices) {
+        sessionServices = await createSessionServices(
+          singletonServices,
+          { http },
+          session
+        )
+      }
+
+      const allServices = {
+        ...singletonServices,
+        ...sessionServices,
+        userSession: userSession,
+      }
+
+      channelHandler.registerOnOpen(() => {
+        if (channelConfig.onConnect && meta.connectPikkuFuncName) {
+          runPikkuFuncDirectly(
+            meta.connectPikkuFuncName,
+            { ...allServices, channel },
+            openingData
+          )
+        }
+      })
+
+      channelHandler.registerOnClose(async () => {
+        if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
+          runPikkuFuncDirectly(
+            meta.disconnectPikkuFuncName,
+            { ...allServices, channel },
+            openingData
+          )
+        }
+        if (sessionServices) {
+          await closeSessionServices(singletonServices.logger, sessionServices)
+        }
+      })
+
+      channelHandler.registerOnMessage(
+        processMessageHandlers(
+          allServices,
+          session,
+          channelConfig as any,
+          channelHandler
+        )
+      )
+    } catch (e: any) {
+      handleError(
+        e,
+        http,
+        channelId,
+        singletonServices.logger,
+        logWarningsForStatusCodes,
+        respondWith404,
+        bubbleErrors
+      )
+    } finally {
+      if (sessionServices) {
+        await closeSessionServices(singletonServices.logger, sessionServices)
+      }
+    }
+  }
+
+  await runMiddleware(
+    {
+      ...singletonServices,
+      userSession,
+    },
+    { http },
+    route.middleware || [],
+    main
+  )
+
+  return channelHandler
+}

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

@@ -0,0 +1,95 @@
+import * as assert from 'assert'
+import { test } from 'node:test'
+import { PikkuChannelHandler } from '../channel.types.js'
+import { CoreUserSession } from '../../types/core.types.js'
+import { LocalEventHubService } from './local-eventhub-service.js'
+
+class MockChannelHandler implements PikkuChannelHandler {
+  private channelId: string
+
+  constructor(channelId: string) {
+    this.channelId = channelId
+  }
+
+  setUserSession(session: CoreUserSession): Promise<void> | void {
+    throw new Error('Method not needed.')
+  }
+
+  getChannel() {
+    return { channelId: this.channelId } as any
+  }
+
+  send(data: unknown, isBinary?: boolean) {
+    // Mock send functionality
+    console.log(`Sent to ${this.channelId}:`, { data, isBinary })
+  }
+}
+
+test('LocalEventHubService: subscribe and unsubscribe', () => {
+  const eventHub = new LocalEventHubService()
+
+  // Subscribe a channel to a topic
+  eventHub.subscribe('topic1', 'channel1')
+  assert.strictEqual(eventHub['subscriptions'].get('topic1')!.size, 1)
+
+  // Unsubscribe the channel
+  eventHub.unsubscribe('topic1', 'channel1')
+  assert.strictEqual(eventHub['subscriptions'].has('topic1'), false)
+})
+
+test('LocalEventHubService: publish messages', () => {
+  const eventHub = new LocalEventHubService()
+
+  // Register mock channels
+  const channel1 = new MockChannelHandler('channel1')
+  const channel2 = new MockChannelHandler('channel2')
+  eventHub.onChannelOpened(channel1)
+  eventHub.onChannelOpened(channel2)
+
+  // Subscribe channels to a topic
+  eventHub.subscribe('topic1', 'channel1')
+  eventHub.subscribe('topic1', 'channel2')
+
+  // Mock `send` method to track calls
+  let sendCallCount = 0
+  channel1.send = () => {
+    sendCallCount++
+  }
+  channel2.send = () => {
+    sendCallCount++
+  }
+
+  // Publish a message
+  eventHub.publish('topic1', 'channel1', { message: 'Hello!' })
+
+  // Ensure the message was sent only to channel2
+  assert.strictEqual(sendCallCount, 1)
+})
+
+test('LocalEventHubService: onChannelOpened and onChannelClosed', () => {
+  const eventHub = new LocalEventHubService()
+
+  // Register and verify channel
+  const channel1 = new MockChannelHandler('channel1')
+  eventHub.onChannelOpened(channel1)
+  assert.strictEqual(eventHub['channels'].has('channel1'), true)
+
+  // Close and verify removal
+  eventHub.onChannelClosed('channel1')
+  assert.strictEqual(eventHub['channels'].has('channel1'), false)
+})
+
+test('LocalEventHubService: clean up empty topics on channel close', () => {
+  const eventHub = new LocalEventHubService()
+
+  // Register and subscribe channels
+  const channel1 = new MockChannelHandler('channel1')
+  eventHub.onChannelOpened(channel1)
+  eventHub.subscribe('topic1', 'channel1')
+
+  // Close channel
+  eventHub.onChannelClosed('channel1')
+
+  // Ensure topic1 is removed
+  assert.strictEqual(eventHub['subscriptions'].has('topic1'), false)
+})

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

@@ -0,0 +1,95 @@
+import { PikkuChannelHandler } from '../channel.types.js'
+import { EventHubService } from '../eventhub-service.js'
+
+/**
+ * Implementation of the SubscriptionService interface.
+ * Manages subscriptions and publishes messages to subscribers.
+ */
+export class LocalEventHubService<Data = unknown>
+  implements EventHubService<Data>
+{
+  private channels = new Map<string, PikkuChannelHandler>()
+
+  /**
+   * A map storing topics and their associated connection IDs.
+   */
+  private subscriptions: Map<string, Set<string>> = new Map()
+
+  /**
+   * Subscribes a connection to a specific topic.
+   * Creates the topic if it does not already exist.
+   * @param topic - The topic to subscribe to.
+   * @param channelId - The unique ID of the connection to subscribe.
+   */
+  public subscribe(topic: string, channelId: string): void {
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, new Set())
+    }
+    this.subscriptions.get(topic)!.add(channelId)
+  }
+
+  /**
+   * Unsubscribes a connection from a specific topic.
+   * Removes the topic if it has no more subscribers.
+   * @param topic - The topic to unsubscribe from.
+   * @param channelId - The unique ID of the connection to unsubscribe.
+   */
+  public unsubscribe(topic: string, channelId: string): void {
+    const topicSubscriptions = this.subscriptions.get(topic)
+    if (topicSubscriptions) {
+      topicSubscriptions.delete(channelId)
+      if (topicSubscriptions.size === 0) {
+        this.subscriptions.delete(topic) // Cleanup empty subscriptions
+      }
+    }
+  }
+
+  /**
+   * Sends data to all connections subscribed to a topic.
+   * @param topic - The topic to send data to.
+   * @param data - The data to send to the subscribers.
+   */
+  public publish(
+    topic: string,
+    channelId: string,
+    data: Data,
+    isBinary?: boolean
+  ): void {
+    const subscribedChannelIds = this.subscriptions.get(topic)
+    if (!subscribedChannelIds) {
+      return
+    }
+    for (const toChannelId of subscribedChannelIds) {
+      if (channelId === toChannelId) continue // Skip sending to the sender
+      const channel = this.channels.get(toChannelId)
+      if (channel) {
+        channel.send(data, isBinary)
+      } else {
+        // TODO: Websocket is closed, remove the channel from the topic
+      }
+    }
+  }
+
+  /**
+   * Registers a channel on open
+   */
+  public onChannelOpened(channelHandler: PikkuChannelHandler): void {
+    this.channels.set(channelHandler.getChannel().channelId, channelHandler)
+  }
+
+  /**
+   * Handles cleanup when a channel is closed.
+   * Removes the channel from all topics it is subscribed to.
+   * Deletes the topic if no more channels are subscribed to it.
+   * @param channelId - The ID of the channel that was closed.
+   */
+  public onChannelClosed(channelId: string): void {
+    for (const [topic, channelIds] of this.subscriptions.entries()) {
+      channelIds.delete(channelId)
+      if (channelIds.size === 0) {
+        this.subscriptions.delete(topic) // Cleanup empty topics
+      }
+    }
+    this.channels.delete(channelId)
+  }
+}

package/src/channel/log-channels.ts

@@ -0,0 +1,20 @@
+import { pikkuState } from '../pikku-state.js'
+import { Logger } from '../services/index.js'
+
+/**
+ * Logs all the loaded channels.
+ * @param logger - A logger for logging information.
+ */
+export const logChannels = (logger: Logger) => {
+  const channels = pikkuState('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/channel/pikku-abstract-channel-handler.test.ts

@@ -0,0 +1,52 @@
+import { test, beforeEach } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { PikkuAbstractChannelHandler } from './pikku-abstract-channel-handler.js'
+
+// A concrete implementation of the abstract class for testing
+class TestChannelHandler extends PikkuAbstractChannelHandler<
+  { param: string },
+  { msg: string }
+> {
+  public async send(message: { msg: string }, isBinary = false): Promise<void> {
+    // Mock send implementation
+  }
+}
+
+let handler: TestChannelHandler
+
+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()'
+  )
+})

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

@@ -0,0 +1,38 @@
+import { PikkuChannel, PikkuChannelHandler } from './channel.types.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 getChannel(): PikkuChannel<OpeningData, Out> {
+    if (!this.channel) {
+      this.channel = {
+        channelId: this.channelId,
+        openingData: this.openingData,
+        send: this.send.bind(this),
+        close: this.close.bind(this),
+        state: 'initial',
+      }
+    }
+    return this.channel
+  }
+
+  public open(): void {
+    this.getChannel().state = 'open'
+  }
+
+  public close(): Promise<void> | void {
+    this.getChannel().state = 'closed'
+  }
+}

package/src/channel/serverless/index.ts

@@ -0,0 +1 @@
+export * from './serverless-channel-runner.js'