@pikku/lambda 0.12.10 → 0.12.12

package/run-tests.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-
-# Enable nullglob to handle cases where no files match the pattern
-shopt -s nullglob
-
-# Initialize variables for options
-watch_mode=false
-coverage_mode=false
-
-# Parse command-line options
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --watch)
-      watch_mode=true
-      shift
-      ;;
-    --coverage)
-      coverage_mode=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Define the pattern to match your test files
-pattern="src/*.test.ts"
-
-# Expand the pattern into an array of files
-files=($(find src -type f -name "*.test.ts"))
-
-# Check if any files matched the pattern
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found matching pattern: $pattern"
-  exit 0
-fi
-
-# Construct the node command
-node_cmd=(node --import tsx --test)
-
-# Append options based on flags
-if [ "$watch_mode" = true ]; then
-  node_cmd+=(--watch)
-fi
-
-if [ "$coverage_mode" = true ]; then
-  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
-fi
-
-# Execute the node command with the expanded list of files
-"${node_cmd[@]}" "${files[@]}"

package/src/handler-factories.ts

@@ -1,164 +0,0 @@
-/**
- * Lambda handler factories — mirrors Cloudflare's handler-factories.ts.
- *
- * Creates combined Lambda handlers based on which handler types a unit needs
- * (fetch, queue, scheduled). Services are cached across warm invocations.
- */
-
-import { LocalVariablesService, LocalSecretService } from '@pikku/core/services'
-import type { CoreSingletonServices } from '@pikku/core/types'
-import type { ChannelStore } from '@pikku/core/channel'
-import { runFetchV2 } from './http/run-fetch-v2.js'
-import { runSQSQueueWorker } from './queue/sqs-worker.js'
-import { runLambdaScheduled } from './scheduled/run-scheduled.js'
-import type {
-  APIGatewayEvent,
-  APIGatewayProxyEventV2,
-  SQSEvent,
-  ScheduledEvent,
-} from 'aws-lambda'
-
-export interface LambdaServiceFactories {
-  createConfig: (
-    variables: LocalVariablesService,
-    ...args: unknown[]
-  ) => Promise<unknown>
-  createSingletonServices: (
-    config: unknown,
-    existingServices?: Partial<Record<string, unknown>>
-  ) => Promise<CoreSingletonServices>
-  /**
-   * Optional callback to create platform services from environment.
-   * Returns services to merge into existingServices.
-   * Generated by the deploy codegen based on unit capabilities.
-   */
-  createPlatformServices?: () =>
-    Record<string, unknown> | Promise<Record<string, unknown>>
-}
-
-let cachedServices: CoreSingletonServices | null = null
-
-async function setupServices(
-  factories: LambdaServiceFactories
-): Promise<CoreSingletonServices> {
-  if (cachedServices) return cachedServices
-  const variables = new LocalVariablesService(
-    process.env as Record<string, string | undefined>
-  )
-  const config = await factories.createConfig(variables)
-  const secrets = new LocalSecretService(variables)
-
-  const platformServices = factories.createPlatformServices
-    ? await factories.createPlatformServices()
-    : {}
-
-  cachedServices = await factories.createSingletonServices(config, {
-    variables,
-    secrets,
-    ...platformServices,
-  })
-  return cachedServices
-}
-
-/**
- * Creates a combined Lambda handler based on which handler types the unit needs.
- *
- * Returns an object with named exports that serverless.yml references:
- * - `handler` for HTTP (API Gateway)
- * - `queue` for SQS
- * - `scheduled` for EventBridge
- */
-export function createLambdaHandler(
-  factories: LambdaServiceFactories,
-  handlerTypes: string[]
-) {
-  const result: Record<string, unknown> = {}
-
-  if (handlerTypes.includes('fetch')) {
-    result.handler = async (event: APIGatewayProxyEventV2) => {
-      await setupServices(factories)
-      return runFetchV2(event)
-    }
-  }
-
-  if (handlerTypes.includes('queue')) {
-    result.queue = async (event: SQSEvent) => {
-      const services = await setupServices(factories)
-      return runSQSQueueWorker(services.logger, event)
-    }
-  }
-
-  if (handlerTypes.includes('scheduled')) {
-    result.scheduled = async (event: ScheduledEvent) => {
-      await setupServices(factories)
-      return runLambdaScheduled(event)
-    }
-  }
-
-  // If no fetch handler was requested, add a health check
-  if (!handlerTypes.includes('fetch')) {
-    const activeHandlers = handlerTypes.join(', ')
-    result.handler = async () => ({
-      statusCode: 200,
-      body: `Lambda active (handlers: ${activeHandlers})`,
-    })
-  }
-
-  return result
-}
-
-/**
- * Creates a Lambda handler with a fetch() entrypoint for HTTP, agent, RPC,
- * and workflow-orchestrator units.
- */
-export function createLambdaWorkerHandler(factories: LambdaServiceFactories) {
-  return {
-    async handler(event: APIGatewayProxyEventV2) {
-      await setupServices(factories)
-      return runFetchV2(event)
-    },
-  }
-}
-
-/**
- * Creates a Lambda handler for WebSocket channel units.
- * Exports separate handlers for $connect, $disconnect, and $default routes.
- */
-export function createLambdaWebSocketHandler(
-  factories: LambdaServiceFactories
-) {
-  // Import dynamically to avoid pulling in websocket deps for non-channel units
-  const getChannelStore = () => {
-    if (!cachedServices) {
-      throw new Error('Services not initialized for WebSocket handler')
-    }
-    const channelStore = (cachedServices as unknown as Record<string, unknown>)
-      .channelStore as ChannelStore | undefined
-    if (!channelStore) {
-      throw new Error(
-        'channelStore not found in singleton services. Ensure it is configured for channel units.'
-      )
-    }
-    return channelStore
-  }
-
-  return {
-    async connect(event: APIGatewayEvent) {
-      await setupServices(factories)
-      const { connectWebsocket } = await import('./websocket/index.js')
-      return connectWebsocket(event, { channelStore: getChannelStore() })
-    },
-    async disconnect(event: APIGatewayEvent) {
-      await setupServices(factories)
-      const { disconnectWebsocket } = await import('./websocket/index.js')
-      return disconnectWebsocket(event, { channelStore: getChannelStore() })
-    },
-    async default(event: APIGatewayEvent) {
-      await setupServices(factories)
-      const { processWebsocketMessage } = await import('./websocket/index.js')
-      return processWebsocketMessage(event, {
-        channelStore: getChannelStore(),
-      })
-    },
-  }
-}

package/src/http/index.ts

@@ -1,2 +0,0 @@
-export * from './run-fetch.js'
-export * from './run-fetch-v2.js'

package/src/http/request-converter-v2.ts

@@ -1,36 +0,0 @@
-import type { APIGatewayProxyEventV2 } from 'aws-lambda'
-
-export const lambdaV2EventToRequest = (
-  event: APIGatewayProxyEventV2
-): Request => {
-  const host =
-    event.headers?.host ?? event.requestContext?.domainName ?? 'localhost'
-  const url = new URL(event.rawPath, `https://${host}`)
-
-  if (event.rawQueryString) {
-    // rawQueryString is already encoded, append directly
-    url.search = `?${event.rawQueryString}`
-  }
-
-  const body =
-    event.body && event.isBase64Encoded
-      ? Buffer.from(event.body, 'base64')
-      : event.body || undefined
-
-  const method = event.requestContext?.http?.method || 'GET'
-
-  const headers: Record<string, string> = {}
-  if (event.headers) {
-    for (const [key, value] of Object.entries(event.headers)) {
-      if (value != null) {
-        headers[key] = value
-      }
-    }
-  }
-
-  return new Request(url.toString(), {
-    method,
-    headers,
-    body: ['GET', 'HEAD'].includes(method.toUpperCase()) ? undefined : body,
-  })
-}

package/src/http/response-converter-v2.ts

@@ -1,40 +0,0 @@
-import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda'
-
-export const responseToLambdaV2Result = async (
-  response: Response
-): Promise<APIGatewayProxyStructuredResultV2> => {
-  // Extract Set-Cookie headers as cookies array (v2 format)
-  const cookies: string[] = response.headers.getSetCookie
-    ? response.headers.getSetCookie()
-    : []
-
-  const headers: Record<string, string> = {}
-  response.headers.forEach((value, key) => {
-    if (key.toLowerCase() === 'set-cookie' && cookies.length > 0) return
-    headers[key.toLowerCase()] = value
-  })
-
-  let body: string
-  let isBase64Encoded = false
-
-  const contentType = response.headers.get('content-type') || ''
-  const isBinary = !/^text\/|application\/(json|javascript|xml)/.test(
-    contentType
-  )
-
-  const buffer = Buffer.from(await response.arrayBuffer())
-  if (isBinary) {
-    body = buffer.toString('base64')
-    isBase64Encoded = true
-  } else {
-    body = buffer.toString('utf-8')
-  }
-
-  return {
-    statusCode: response.status,
-    headers,
-    body,
-    isBase64Encoded,
-    ...(cookies.length > 0 ? { cookies } : {}),
-  }
-}

package/src/http/run-fetch-v2.ts

@@ -1,42 +0,0 @@
-import { PikkuFetchHTTPResponse, fetchData } from '@pikku/core/http'
-import type {
-  APIGatewayProxyEventV2,
-  APIGatewayProxyStructuredResultV2,
-} from 'aws-lambda'
-import { responseToLambdaV2Result } from './response-converter-v2.js'
-import { lambdaV2EventToRequest } from './request-converter-v2.js'
-
-export const runFetchV2 = async (
-  event: APIGatewayProxyEventV2
-): Promise<APIGatewayProxyStructuredResultV2> => {
-  const request = lambdaV2EventToRequest(event)
-  const response = new PikkuFetchHTTPResponse()
-
-  if (request.method === 'OPTIONS') {
-    response.header(
-      'Access-Control-Allow-Origin',
-      request.headers.get('origin') || '*'
-    )
-    response.header(
-      'Access-Control-Allow-Headers',
-      'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'
-    )
-    response.header(
-      'Access-Control-Allow-Methods',
-      'OPTIONS,DELETE,GET,HEAD,PATCH,POST,PUT'
-    )
-    response.status(200)
-    return responseToLambdaV2Result(response.toResponse())
-  }
-
-  try {
-    await fetchData(request, response)
-  } catch (err) {
-    console.error('fetchData error:', err)
-    response.status(500)
-    response.header('content-type', 'application/json')
-    response.json({ error: 'Internal Server Error' })
-  }
-
-  return responseToLambdaV2Result(response.toResponse())
-}

package/src/http/run-fetch.ts

@@ -1,32 +0,0 @@
-import { PikkuFetchHTTPResponse, fetchData } from '@pikku/core/http'
-import type { APIGatewayEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { responseToLambdaResult } from '../response-converter.js'
-import { lambdaEventToRequest } from '../request-converter.js'
-
-export const runFetch = async (
-  event: APIGatewayEvent
-): Promise<APIGatewayProxyResult> => {
-  const request = lambdaEventToRequest(event)
-  const response = new PikkuFetchHTTPResponse()
-
-  if (request.method === 'OPTIONS') {
-    response.header(
-      'Access-Control-Allow-Headers',
-      'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'
-    )
-    response.header(
-      'Access-Control-Allow-Methods',
-      'OPTIONS,DELETE,GET,HEAD,PATCH,POST,PUT'
-    )
-    response.status(200)
-    return responseToLambdaResult(response.toResponse())
-  }
-
-  try {
-    await fetchData(request, response)
-  } catch {
-    // Error should have already been handled by fetch
-  }
-
-  return responseToLambdaResult(response.toResponse())
-}

package/src/index.test.ts

@@ -1,13 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, test } from 'node:test'
-
-import * as lambdaRuntime from './index.js'
-
-describe('@pikku/lambda', () => {
-  test('exports the lambda runtime API', () => {
-    assert.equal(typeof lambdaRuntime.createLambdaHandler, 'function')
-    assert.equal(typeof lambdaRuntime.LambdaDeploymentService, 'function')
-    assert.equal(typeof lambdaRuntime.SQSQueueService, 'function')
-    assert.equal(typeof lambdaRuntime.runFetch, 'function')
-  })
-})

package/src/index.ts

@@ -1,11 +0,0 @@
-export * from './http/index.js'
-export * from './websocket/index.js'
-export * from './queue/index.js'
-export * from './scheduled/index.js'
-export {
-  createLambdaHandler,
-  createLambdaWorkerHandler,
-  createLambdaWebSocketHandler,
-} from './handler-factories.js'
-export { SQSQueueService } from './sqs-queue-service.js'
-export { LambdaDeploymentService } from './lambda-deployment-service.js'

package/src/lambda-deployment-service.ts

@@ -1,115 +0,0 @@
-/**
- * Lambda deployment service — routes remote() calls via Lambda Invoke.
- *
- * When a gateway (agent, MCP, channel, workflow orchestrator) calls
- * remote('funcName'), this service dispatches to the function's Lambda
- * via the AWS SDK InvokeCommand. Equivalent to Cloudflare's service bindings.
- *
- * Session propagation uses the existing pikkuRemoteAuthMiddleware:
- * JWT signed with PIKKU_REMOTE_SECRET, session encrypted in payload.
- */
-
-import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda'
-import type { DeploymentService, DeploymentConfig } from '@pikku/core/services'
-import type { JWTService } from '@pikku/core/services'
-import type { SecretService } from '@pikku/core/services'
-import { buildRemoteHeaders } from '@pikku/core/remote'
-
-export class LambdaDeploymentService implements DeploymentService {
-  private client: LambdaClient
-  private bindings: Map<string, string>
-
-  constructor(
-    private jwt: JWTService | undefined,
-    private secrets: SecretService,
-    functionBindings: Record<string, string>
-  ) {
-    this.client = new LambdaClient({})
-    this.bindings = new Map(Object.entries(functionBindings))
-  }
-
-  async init(): Promise<void> {}
-  async start(_config: DeploymentConfig): Promise<void> {}
-  async stop(): Promise<void> {}
-
-  async invoke(
-    funcName: string,
-    data: unknown,
-    session?: unknown,
-    traceId?: string
-  ): Promise<unknown> {
-    const lambdaFunctionName = this.bindings.get(funcName)
-    if (!lambdaFunctionName) {
-      throw new Error(
-        `No Lambda binding for function '${funcName}'. ` +
-          `Available bindings: ${[...this.bindings.keys()].join(', ')}`
-      )
-    }
-
-    const headers = await buildRemoteHeaders(
-      this.jwt,
-      this.secrets,
-      funcName,
-      session,
-      traceId
-    )
-
-    // Build an API Gateway v2 event for the target Lambda
-    const rpcPath = `/remote/rpc/${encodeURIComponent(funcName)}`
-    const apiGatewayEvent = {
-      httpMethod: 'POST',
-      path: rpcPath,
-      headers,
-      body: JSON.stringify({ data }),
-      isBase64Encoded: false,
-      queryStringParameters: null,
-      pathParameters: null,
-      stageVariables: null,
-      requestContext: {
-        httpMethod: 'POST',
-        path: rpcPath,
-        stage: 'prod',
-        requestId: crypto.randomUUID(),
-        identity: {},
-      },
-      resource: rpcPath,
-    }
-
-    const response = await this.client.send(
-      new InvokeCommand({
-        FunctionName: lambdaFunctionName,
-        Payload: JSON.stringify(apiGatewayEvent),
-      })
-    )
-
-    if (response.FunctionError) {
-      const errorPayload = response.Payload
-        ? new TextDecoder().decode(response.Payload)
-        : 'Unknown error'
-      throw new Error(
-        `Remote RPC call to '${funcName}' failed: Lambda error: ${errorPayload}`
-      )
-    }
-
-    if (!response.Payload) {
-      throw new Error(`Remote RPC call to '${funcName}' returned no payload`)
-    }
-
-    // The Lambda returns an API Gateway response shape
-    const lambdaResult = JSON.parse(new TextDecoder().decode(response.Payload))
-
-    if (lambdaResult.statusCode && lambdaResult.statusCode >= 400) {
-      throw new Error(
-        `Remote RPC call to '${funcName}' failed: ${lambdaResult.statusCode} ${lambdaResult.body}`
-      )
-    }
-
-    // Parse the body from the API Gateway response
-    const body = lambdaResult.body
-    try {
-      return JSON.parse(body)
-    } catch {
-      return body
-    }
-  }
-}

package/src/queue/index.ts

@@ -1 +0,0 @@
-export { runSQSQueueWorker } from './sqs-worker.js'

package/src/queue/sqs-worker.ts

@@ -1,101 +0,0 @@
-import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda'
-import { runQueueJob } from '@pikku/core/queue'
-import { QueueJobFailedError, QueueJobDiscardedError } from '@pikku/core/queue'
-import type { Logger } from '@pikku/core/services'
-import type { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-
-/**
- * Enhanced version with additional SQS-specific features
- */
-export function mapSQSRecordToQueueJob(
-  record: SQSRecord,
-  maxAttempts?: number
-): QueueJob {
-  let data: any
-
-  try {
-    data = JSON.parse(record.body)
-  } catch {
-    data = record.body
-  }
-
-  if (!record.eventSourceARN) {
-    throw new Error('SQS record does not have eventSourceARN')
-  }
-
-  const queueName = record.eventSourceARN.split(':').pop()!
-
-  const job: QueueJob = {
-    queueName,
-    data,
-    id: record.messageId,
-    status: async () => 'active' as QueueJobStatus,
-    metadata: () => ({
-      processedAt: new Date(),
-      attemptsMade: parseInt(record.attributes.ApproximateReceiveCount) - 1,
-      maxAttempts,
-      result: undefined,
-      progress: 0,
-      createdAt: new Date(parseInt(record.attributes.SentTimestamp)),
-      completedAt: undefined,
-      failedAt: undefined,
-      error: undefined,
-    }),
-    waitForCompletion: async () => {
-      throw new Error(
-        'SQS does not support waitForCompletion - jobs are fire-and-forget'
-      )
-    },
-  }
-  return job
-}
-
-/**
- * Create an SQS handler that processes queue jobs using Pikku
- */
-export const runSQSQueueWorker = async (
-  logger: Logger,
-  event: SQSEvent
-): Promise<SQSBatchResponse> => {
-  logger.info(`Processing ${event.Records.length} SQS messages`)
-  const jobs = event.Records.map(mapSQSRecordToQueueJob)
-
-  // Process all jobs in parallel
-  const results = await Promise.allSettled(
-    jobs.map(async (job) => {
-      try {
-        return await runQueueJob({ job })
-      } catch (error: unknown) {
-        if (error instanceof QueueJobFailedError) {
-          // Let SQS handle this as a failed job (will go to retry or DLQ)
-          throw error
-        } else if (error instanceof QueueJobDiscardedError) {
-          // For SQS, discarding means completing successfully (no retry)
-          logger.info(`SQS job ${job.id} discarded: ${error.message}`)
-          return
-        }
-        throw error
-      }
-    })
-  )
-
-  // Log any failures but don't throw (SQS will handle retries)
-  results.forEach((result, index) => {
-    if (result.status === 'rejected') {
-      logger.error(
-        `Failed to process SQS message ${jobs[index]!.id}:`,
-        result.reason
-      )
-    }
-  })
-
-  return {
-    batchItemFailures: results
-      .map((result, index) => ({
-        result,
-        itemIdentifier: jobs[index]!.id || `message-${index}`,
-      }))
-      .filter(({ result }) => result.status === 'rejected')
-      .map(({ itemIdentifier }) => ({ itemIdentifier })),
-  }
-}

package/src/request-converter.ts

@@ -1,24 +0,0 @@
-import type { APIGatewayProxyEvent } from 'aws-lambda'
-
-export const lambdaEventToRequest = (event: APIGatewayProxyEvent): Request => {
-  const url = new URL(event.path, `https://${event.headers.host}`)
-
-  if (event.queryStringParameters) {
-    for (const [key, value] of Object.entries(event.queryStringParameters)) {
-      if (value !== undefined) url.searchParams.set(key, value)
-    }
-  }
-
-  const body =
-    event.body && event.isBase64Encoded
-      ? Buffer.from(event.body, 'base64')
-      : event.body || undefined
-
-  const method = event.httpMethod || 'GET'
-
-  return new Request(url.toString(), {
-    method,
-    headers: event.headers as HeadersInit,
-    body: ['GET', 'HEAD'].includes(method.toUpperCase()) ? undefined : body,
-  })
-}

package/src/response-converter.ts

@@ -1,33 +0,0 @@
-import type { APIGatewayProxyResult } from 'aws-lambda'
-
-export const responseToLambdaResult = async (
-  response: Response
-): Promise<APIGatewayProxyResult> => {
-  const headers: Record<string, string> = {}
-  response.headers.forEach((value, key) => {
-    headers[key.toLowerCase()] = value
-  })
-
-  let body: string
-  let isBase64Encoded = false
-
-  const contentType = response.headers.get('content-type') || ''
-  const isBinary = !/^text\/|application\/(json|javascript|xml)/.test(
-    contentType
-  )
-
-  const buffer = Buffer.from(await response.arrayBuffer())
-  if (isBinary) {
-    body = buffer.toString('base64')
-    isBase64Encoded = true
-  } else {
-    body = buffer.toString('utf-8')
-  }
-
-  return {
-    statusCode: response.status,
-    headers,
-    body,
-    isBase64Encoded,
-  }
-}

package/src/scheduled/index.ts

@@ -1 +0,0 @@
-export { runLambdaScheduled } from './run-scheduled.js'