@pikku/lambda 0.12.10 → 0.12.12

package/src/scheduled/run-scheduled.ts

@@ -1,31 +0,0 @@
-/**
- * Lambda handler for EventBridge scheduled events.
- *
- * Since each Lambda corresponds to a single unit, and each unit has
- * specific scheduled tasks registered, we run all tasks in this unit
- * when the schedule fires.
- */
-
-import type { ScheduledEvent } from 'aws-lambda'
-import { runScheduledTask } from '@pikku/core/scheduler'
-import { getScheduledTasks } from '@pikku/core/scheduler'
-
-export const runLambdaScheduled = async (
-  _event: ScheduledEvent
-): Promise<void> => {
-  const scheduledTasks = getScheduledTasks()
-
-  // Run all scheduled tasks registered in this unit.
-  // Typically one task per unit, but iterate all to be safe.
-  for (const [name] of scheduledTasks) {
-    const traceId = `cron-${crypto.randomUUID()}`
-    try {
-      await runScheduledTask({ name, traceId })
-    } catch (err) {
-      console.error(
-        `Scheduled task '${name}' (traceId: ${traceId}) failed:`,
-        err
-      )
-    }
-  }
-}

package/src/sqs-queue-service.ts

@@ -1,92 +0,0 @@
-/**
- * SQS implementation of QueueService (producer side).
- *
- * Sends messages to SQS queues. Queue URLs are resolved from environment
- * variables following the convention: SQS_QUEUE_URL_<SCREAMING_SNAKE_NAME>.
- *
- * The consumer side is handled by sqs-worker.ts (runSQSQueueWorker).
- */
-
-import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs'
-import type { QueueService, QueueJob } from '@pikku/core/queue'
-import type { JobOptions } from '@pikku/core/queue'
-
-export class SQSQueueService implements QueueService {
-  readonly supportsResults = false
-  private client: SQSClient
-
-  constructor(private queueUrlMap?: Record<string, string>) {
-    this.client = new SQSClient({})
-  }
-
-  async add<T>(
-    queueName: string,
-    data: T,
-    options?: JobOptions
-  ): Promise<string> {
-    const queueUrl = this.resolveQueueUrl(queueName)
-    const messageId = crypto.randomUUID()
-
-    const message = {
-      id: messageId,
-      queueName,
-      data,
-      pikkuUserId: options?.pikkuUserId,
-    }
-
-    const result = await this.client.send(
-      new SendMessageCommand({
-        QueueUrl: queueUrl,
-        MessageBody: JSON.stringify(message),
-        DelaySeconds: options?.delay
-          ? Math.min(Math.ceil(options.delay / 1000), 900)
-          : undefined,
-      })
-    )
-
-    return result.MessageId ?? messageId
-  }
-
-  async getJob<T, R>(
-    _queueName: string,
-    _jobId: string
-  ): Promise<QueueJob<T, R> | null> {
-    throw new Error(
-      'SQSQueueService does not support getJob(). ' +
-        'SQS is fire-and-forget. ' +
-        'Use BullMQ or PgBoss if you need job result tracking.'
-    )
-  }
-
-  /**
-   * Resolves the SQS queue URL for a given queue name.
-   *
-   * Checks in order:
-   * 1. Explicit queueUrlMap passed in constructor
-   * 2. Environment variable SQS_QUEUE_URL_<SCREAMING_SNAKE>
-   */
-  private resolveQueueUrl(queueName: string): string {
-    if (this.queueUrlMap?.[queueName]) {
-      return this.queueUrlMap[queueName]
-    }
-
-    const envKey = `SQS_QUEUE_URL_${toScreamingSnake(queueName)}`
-    const url = process.env[envKey]
-
-    if (!url) {
-      throw new Error(
-        `SQS queue URL not found for queue "${queueName}". ` +
-          `Set environment variable ${envKey} or pass queueUrlMap to constructor.`
-      )
-    }
-
-    return url
-  }
-}
-
-function toScreamingSnake(name: string): string {
-  return name
-    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-    .replace(/-/g, '_')
-    .toUpperCase()
-}

package/src/websocket/index.ts

@@ -1,4 +0,0 @@
-export * from './websocket-message.js'
-export * from './websocket-connect.js'
-export * from './websocket-disconnect.js'
-export * from './lambda-eventhub-service.js'

package/src/websocket/lambda-channel-handler.ts

@@ -1,58 +0,0 @@
-import type { CoreUserSession } from '@pikku/core/types'
-import type { ChannelStore } from '@pikku/core/channel'
-import type {
-  BinaryData,
-  PikkuChannelHandlerFactory,
-} from '@pikku/core/channel'
-import { PikkuAbstractChannelHandler } from '@pikku/core/channel'
-import { sendMessage } from './utils.js'
-import type { ApiGatewayManagementApiClient } from '@aws-sdk/client-apigatewaymanagementapi'
-import type { Logger } from '@pikku/core/services'
-
-class LambdaChannelHandler<
-  UserSession extends CoreUserSession = CoreUserSession,
-  OpeningData = unknown,
-  Out = unknown,
-> extends PikkuAbstractChannelHandler<OpeningData, Out> {
-  constructor(
-    private logger: Logger,
-    private callbackAPI: ApiGatewayManagementApiClient,
-    channelId: string,
-    channelName: string,
-    openingData: OpeningData
-  ) {
-    super(channelId, channelName, openingData)
-  }
-
-  public async send(message: Out, isBinary?: boolean) {
-    if (isBinary) {
-      throw new Error('Binary data is not supported on serverless lambdas')
-    }
-    const data = JSON.stringify(message)
-    await sendMessage(this.logger, this.callbackAPI, this.channelId, data)
-  }
-
-  public sendBinary(_data: BinaryData): void {
-    throw new Error('Binary data is not supported on serverless lambdas')
-  }
-}
-
-export const createLambdaChannelHandlerFactory = (
-  logger: Logger,
-  channelStore: ChannelStore,
-  callbackAPI: ApiGatewayManagementApiClient
-) => {
-  const factory: PikkuChannelHandlerFactory = (
-    channelId,
-    channelName,
-    openingData
-  ) =>
-    new LambdaChannelHandler(
-      logger,
-      callbackAPI,
-      channelId,
-      channelName,
-      openingData
-    )
-  return factory
-}

package/src/websocket/lambda-eventhub-service.ts

@@ -1,66 +0,0 @@
-import type { ApiGatewayManagementApiClient } from '@aws-sdk/client-apigatewaymanagementapi'
-import type { ChannelStore, EventHubService } from '@pikku/core/channel'
-import type { EventHubStore } from '@pikku/core/channel'
-import { getApiGatewayManagementApiClient, sendMessages } from './utils.js'
-import type { Logger } from '@pikku/core/services'
-import type { APIGatewayEvent } from 'aws-lambda'
-
-export class LambdaEventHubService<
-  EventTopics extends Record<string, any> = {},
-> implements EventHubService<EventTopics> {
-  private callbackAPI: ApiGatewayManagementApiClient
-
-  constructor(
-    private logger: Logger,
-    event: APIGatewayEvent,
-    private channelStore: ChannelStore,
-    private eventHubStore: EventHubStore<EventTopics>
-  ) {
-    this.callbackAPI = getApiGatewayManagementApiClient(logger, event)
-  }
-
-  async subscribe<T extends keyof EventTopics>(
-    topic: T,
-    channelId: string
-  ): Promise<void> {
-    await this.eventHubStore.subscribe(topic, channelId)
-  }
-
-  async unsubscribe<T extends keyof EventTopics>(
-    topic: T,
-    channelId: string
-  ): Promise<void> {
-    await this.eventHubStore.unsubscribe(topic, channelId)
-  }
-
-  async publish<T extends keyof EventTopics>(
-    topic: T,
-    channelId: string | null,
-    data: EventTopics[T],
-    isBinary?: boolean
-  ): Promise<void> {
-    const channelIds = await this.eventHubStore.getChannelIdsForTopic(
-      topic as string
-    )
-    if (channelId) {
-      await this.sendMessages(channelIds, channelId, data, isBinary)
-    }
-  }
-
-  private async sendMessages(
-    channelIds: string[],
-    fromChannelId: string,
-    data: EventTopics[keyof EventTopics],
-    isBinary?: boolean
-  ): Promise<void> {
-    await sendMessages(
-      this.logger,
-      this.channelStore,
-      this.callbackAPI,
-      fromChannelId,
-      channelIds,
-      data,
-      isBinary
-    )
-  }
-}

package/src/websocket/utils.ts

@@ -1,96 +0,0 @@
-import {
-  ApiGatewayManagementApiClient,
-  PostToConnectionCommand,
-} from '@aws-sdk/client-apigatewaymanagementapi'
-import type { Logger } from '@pikku/core/services'
-import { getSingletonServices } from '@pikku/core/state'
-import type { APIGatewayEvent } from 'aws-lambda'
-import { createLambdaChannelHandlerFactory } from './lambda-channel-handler.js'
-import type { ChannelStore } from '@pikku/core/channel'
-
-export const sendMessage = async (
-  logger: Logger,
-  callbackAPI: ApiGatewayManagementApiClient,
-  ConnectionId: string,
-  Data: string
-): Promise<boolean> => {
-  try {
-    await callbackAPI.send(new PostToConnectionCommand({ ConnectionId, Data }))
-    return true
-  } catch (e: any) {
-    // TODO: We need to check if it's a 410 and remove the connection if it is
-    // Otherwise we need to log the error
-    logger.error(e.message)
-    return false
-  }
-}
-
-export const sendMessages = async (
-  logger: Logger,
-  channelStore: ChannelStore,
-  callbackAPI: ApiGatewayManagementApiClient,
-  fromChannelId: string,
-  channelIds: string[],
-  data: unknown,
-  isBinary?: boolean
-): Promise<void> => {
-  if (isBinary) {
-    throw new Error('Binary data is not supported on serverless lambdas')
-  }
-  const staleWebsockets: string[] = []
-  const Data = JSON.stringify(data)
-  await Promise.all(
-    channelIds.map(async (channelId) => {
-      if (channelId !== fromChannelId) {
-        const success = await sendMessage(logger, callbackAPI, channelId, Data)
-        if (!success) {
-          staleWebsockets.push(channelId)
-        }
-      }
-    })
-  )
-  if (staleWebsockets.length > 0) {
-    await channelStore.removeChannels(staleWebsockets)
-  }
-}
-
-export const getApiGatewayManagementApiClient = (
-  logger: Logger,
-  event: APIGatewayEvent
-) => {
-  let endpoint: string
-  if (process.env.IS_OFFLINE) {
-    logger.info('Assuming serverless offline mode due to IS_OFFLINE')
-    endpoint = `http://localhost:3001`
-  } else if (event.requestContext.domainName?.includes('amazonaws.com')) {
-    logger.info(
-      'Assuming we are using the default endpoint mode due to amazonaws.com domain'
-    )
-    endpoint = `https://${event.requestContext.domainName}/${event.requestContext.stage}`
-  } else {
-    logger.info('Assuming we are using a custom domain mode')
-    endpoint = `https://${event.requestContext.domainName}`
-  }
-  return new ApiGatewayManagementApiClient({
-    apiVersion: '2018-11-29',
-    endpoint,
-  })
-}
-
-export const getServerlessDependencies = (
-  channelStore: ChannelStore,
-  event: APIGatewayEvent
-) => {
-  const { logger } = getSingletonServices()
-  const channelId = event.requestContext.connectionId
-  if (!channelId) {
-    throw new Error('No connectionId found in requestContext')
-  }
-  const callbackAPI = getApiGatewayManagementApiClient(logger, event)
-  const channelHandlerFactory = createLambdaChannelHandlerFactory(
-    logger,
-    channelStore,
-    callbackAPI
-  )
-  return { channelId, callbackAPI, channelHandlerFactory, channelStore }
-}

package/src/websocket/websocket-connect.ts

@@ -1,23 +0,0 @@
-import { PikkuFetchHTTPRequest, PikkuFetchHTTPResponse } from '@pikku/core/http'
-import type { APIGatewayEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { responseToLambdaResult } from '../response-converter.js'
-import { runChannelConnect } from '@pikku/core/channel/serverless'
-import { getServerlessDependencies } from './utils.js'
-import type { WebsocketParams } from './websocket-types.js'
-import { lambdaEventToRequest } from '../request-converter.js'
-
-export const connectWebsocket = async (
-  event: APIGatewayEvent,
-  { channelStore }: WebsocketParams
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(channelStore, event)
-  const request = new PikkuFetchHTTPRequest(lambdaEventToRequest(event))
-  const response = new PikkuFetchHTTPResponse()
-  await runChannelConnect({
-    ...runnerParams,
-    request,
-    response,
-    route: event.path || '/',
-  })
-  return responseToLambdaResult(response.toResponse())
-}

package/src/websocket/websocket-disconnect.ts

@@ -1,14 +0,0 @@
-import { runChannelDisconnect } from '@pikku/core/channel/serverless'
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda'
-
-import { getServerlessDependencies } from './utils.js'
-import type { WebsocketParams } from './websocket-types.js'
-
-export const disconnectWebsocket = async (
-  event: APIGatewayProxyEvent,
-  { channelStore }: WebsocketParams
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(channelStore, event)
-  await runChannelDisconnect(runnerParams)
-  return { statusCode: 200, body: '' }
-}

package/src/websocket/websocket-message.ts

@@ -1,23 +0,0 @@
-import { PikkuFetchHTTPResponse } from '@pikku/core/http'
-import { runChannelMessage } from '@pikku/core/channel/serverless'
-import type { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { getServerlessDependencies } from './utils.js'
-import type { WebsocketParams } from './websocket-types.js'
-import { responseToLambdaResult } from '../response-converter.js'
-
-export const processWebsocketMessage = async (
-  event: APIGatewayProxyEvent,
-  { channelStore }: WebsocketParams
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(channelStore, event)
-  const response = new PikkuFetchHTTPResponse()
-  try {
-    const result = await runChannelMessage(runnerParams, event.body)
-    if (result) {
-      response.json(result as any)
-    }
-  } catch (e) {
-    console.error(e)
-  }
-  return responseToLambdaResult(response.toResponse())
-}

package/src/websocket/websocket-types.ts

@@ -1,5 +0,0 @@
-import type { ChannelStore } from '@pikku/core/channel'
-
-export type WebsocketParams = {
-  channelStore: ChannelStore
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true
-  },
-  "include": ["bin/**/*.ts", "src/**/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
-  "references": [
-    {
-      "path": "../../core/tsconfig.json"
-    }
-  ]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/handler-factories.ts","./src/index.ts","./src/lambda-deployment-service.ts","./src/request-converter.ts","./src/response-converter.ts","./src/sqs-queue-service.ts","./src/http/index.ts","./src/http/request-converter-v2.ts","./src/http/response-converter-v2.ts","./src/http/run-fetch-v2.ts","./src/http/run-fetch.ts","./src/queue/index.ts","./src/queue/sqs-worker.ts","./src/scheduled/index.ts","./src/scheduled/run-scheduled.ts","./src/websocket/index.ts","./src/websocket/lambda-channel-handler.ts","./src/websocket/lambda-eventhub-service.ts","./src/websocket/utils.ts","./src/websocket/websocket-connect.ts","./src/websocket/websocket-disconnect.ts","./src/websocket/websocket-message.ts","./src/websocket/websocket-types.ts"],"version":"6.0.3"}