@pikku/lambda 0.6.8 → 0.7.0

package/CHANGELOG.md

@@ -1,4 +1,6 @@
-## 0.6.1
+## 0.7.0
+
+- Updating to match remaining packages
 
 ## 0.6.8
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/lambda",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "license": "MIT",
   "author": "yasser.fadl@gmail.com",
   "module": "dist/index.js",
@@ -23,7 +23,7 @@
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.713.0",
-    "@pikku/core": "^0.6.22",
+    "@pikku/core": "^0.7.0",
     "@types/aws-lambda": "^8.10.146"
   },
   "devDependencies": {

package/src/http/index.ts

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

package/src/http/run-fetch.ts

@@ -1,51 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  CreateSessionServices,
-  CoreUserSession,
-} from '@pikku/core'
-import { PikkuFetchHTTPResponse, fetchData } from '@pikku/core/http'
-import { APIGatewayEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { responseToLambdaResult } from '../response-converter.js'
-import { lambdaEventToRequest } from '../request-converter.js'
-
-export const runFetch = async <
-  SingletonServices extends CoreSingletonServices,
-  Services extends CoreServices<SingletonServices>,
-  UserSession extends CoreUserSession,
->(
-  singletonServices: SingletonServices,
-  createSessionServices: CreateSessionServices<
-    SingletonServices,
-    Services,
-    UserSession
-  >,
-  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, {
-      singletonServices,
-      createSessionServices: createSessionServices as any,
-    })
-  } catch {
-    // Error should have already been handled by fetch
-  }
-
-  return responseToLambdaResult(response.toResponse())
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './http/index.js'
-export * from './websocket/index.js'

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
-
-  return new Request(url.toString(), {
-    method: event.httpMethod,
-    headers: event.headers as HeadersInit,
-    body: ['GET', 'HEAD'].includes(event.httpMethod.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/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,53 +0,0 @@
-import { CoreUserSession } from '@pikku/core'
-import {
-  ChannelStore,
-  PikkuAbstractChannelHandler,
-  PikkuChannelHandlerFactory,
-} from '@pikku/core/channel'
-import { sendMessage } from './utils.js'
-import { ApiGatewayManagementApiClient } from '@aws-sdk/client-apigatewaymanagementapi'
-import { 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)
-  }
-}
-
-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,59 +0,0 @@
-import { ApiGatewayManagementApiClient } from '@aws-sdk/client-apigatewaymanagementapi'
-import {
-  ChannelStore,
-  EventHubService,
-  EventHubStore,
-} from '@pikku/core/channel'
-import { getApiGatewayManagementApiClient, sendMessages } from './utils.js'
-import { Logger } from '@pikku/core/services'
-import { APIGatewayEvent } from 'aws-lambda'
-
-export class LambdaEventHubService<Out = unknown>
-  implements EventHubService<Out>
-{
-  private callbackAPI: ApiGatewayManagementApiClient
-
-  constructor(
-    private logger: Logger,
-    event: APIGatewayEvent,
-    private channelStore: ChannelStore,
-    private eventHubStore: EventHubStore
-  ) {
-    this.callbackAPI = getApiGatewayManagementApiClient(logger, event)
-  }
-
-  async subscribe(topic: string, channelId: string): Promise<void> {
-    await this.eventHubStore.subscribe(topic, channelId)
-  }
-
-  async unsubscribe(topic: string, channelId: string): Promise<void> {
-    await this.eventHubStore.unsubscribe(topic, channelId)
-  }
-
-  async publish(
-    topic: string,
-    fromChannelId: string,
-    data: Out,
-    isBinary?: boolean
-  ): Promise<void> {
-    const channelIds = await this.eventHubStore.getChannelIdsForTopic(topic)
-    await this.sendMessages(channelIds, fromChannelId, data)
-  }
-
-  private async sendMessages(
-    channelIds: string[],
-    fromChannelId: string,
-    data: Out,
-    isBinary?: boolean
-  ): Promise<void> {
-    await sendMessages(
-      this.logger,
-      this.channelStore,
-      this.callbackAPI,
-      fromChannelId,
-      channelIds,
-      data,
-      isBinary
-    )
-  }
-}

package/src/websocket/utils.ts

@@ -1,95 +0,0 @@
-import {
-  ApiGatewayManagementApiClient,
-  PostToConnectionCommand,
-} from '@aws-sdk/client-apigatewaymanagementapi'
-import { Logger } from '@pikku/core/services'
-import { APIGatewayEvent } from 'aws-lambda'
-import { createLambdaChannelHandlerFactory } from './lambda-channel-handler.js'
-import { 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 = (
-  logger: Logger,
-  channelStore: ChannelStore,
-  event: APIGatewayEvent
-) => {
-  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,43 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-  PikkuFetchHTTPRequest,
-  PikkuFetchHTTPResponse,
-} from '@pikku/core'
-import { APIGatewayEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { responseToLambdaResult } from '../response-converter.js'
-import { runChannelConnect } from '@pikku/core/channel/serverless'
-import { getServerlessDependencies } from './utils.js'
-import { WebsocketParams } from './websocket-types.js'
-import { lambdaEventToRequest } from '../request-converter.js'
-
-export const connectWebsocket = async <
-  SingletonServices extends CoreSingletonServices,
-  Services extends CoreServices<SingletonServices>,
-  UserSession extends CoreUserSession,
->(
-  event: APIGatewayEvent,
-  {
-    singletonServices,
-    createSessionServices,
-    channelStore,
-  }: WebsocketParams<SingletonServices, Services, UserSession>
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(
-    singletonServices.logger,
-    channelStore,
-    event
-  )
-  const request = new PikkuFetchHTTPRequest(lambdaEventToRequest(event))
-  const response = new PikkuFetchHTTPResponse()
-  await runChannelConnect({
-    ...runnerParams,
-    request,
-    response,
-    singletonServices: singletonServices as any,
-    createSessionServices: createSessionServices as any,
-    route: event.path || '/',
-  })
-  return responseToLambdaResult(response.toResponse())
-}

package/src/websocket/websocket-disconnect.ts

@@ -1,35 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-} from '@pikku/core'
-import { runChannelDisconnect } from '@pikku/core/channel/serverless'
-import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda'
-
-import { getServerlessDependencies } from './utils.js'
-import { WebsocketParams } from './websocket-types.js'
-
-export const disconnectWebsocket = async <
-  SingletonServices extends CoreSingletonServices,
-  Services extends CoreServices<SingletonServices>,
-  UserSession extends CoreUserSession,
->(
-  event: APIGatewayProxyEvent,
-  {
-    singletonServices,
-    createSessionServices,
-    channelStore,
-  }: WebsocketParams<SingletonServices, Services, UserSession>
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(
-    singletonServices.logger,
-    channelStore,
-    event
-  )
-  await runChannelDisconnect({
-    ...runnerParams,
-    singletonServices: singletonServices as any,
-    createSessionServices: createSessionServices as any,
-  })
-  return { statusCode: 200, body: '' }
-}

package/src/websocket/websocket-message.ts

@@ -1,49 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-  PikkuFetchHTTPResponse,
-} from '@pikku/core'
-import { runChannelMessage } from '@pikku/core/channel/serverless'
-import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda'
-import { getServerlessDependencies } from './utils.js'
-import { WebsocketParams } from './websocket-types.js'
-import { responseToLambdaResult } from '../response-converter.js'
-
-export const processWebsocketMessage = async <
-  SingletonServices extends CoreSingletonServices,
-  Services extends CoreServices<SingletonServices>,
-  UserSession extends CoreUserSession,
->(
-  event: APIGatewayProxyEvent,
-  {
-    singletonServices,
-    createSessionServices,
-    channelStore,
-  }: WebsocketParams<SingletonServices, Services, UserSession>
-): Promise<APIGatewayProxyResult> => {
-  const runnerParams = getServerlessDependencies(
-    singletonServices.logger,
-    channelStore,
-    event
-  )
-  const response = new PikkuFetchHTTPResponse()
-  try {
-    const result = await runChannelMessage(
-      {
-        ...runnerParams,
-        singletonServices: singletonServices as any,
-        createSessionServices: createSessionServices as any,
-      },
-      event.body
-    )
-    if (result) {
-      // TODO: Support non json
-      response.json(result as any)
-    }
-  } catch (e) {
-    // Error should have already been handled by fetch
-    console.error(e)
-  }
-  return responseToLambdaResult(response.toResponse())
-}

package/src/websocket/websocket-types.ts

@@ -1,21 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  CoreUserSession,
-  CreateSessionServices,
-} from '@pikku/core'
-import { ChannelStore } from '@pikku/core/channel'
-
-export type WebsocketParams<
-  SingletonServices extends CoreSingletonServices,
-  Services extends CoreServices<SingletonServices>,
-  UserSession extends CoreUserSession,
-> = {
-  channelStore: ChannelStore
-  singletonServices: SingletonServices
-  createSessionServices?: CreateSessionServices<
-    SingletonServices,
-    Services,
-    UserSession
-  >
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "module": "Node16",
-    "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/index.ts","./src/request-converter.ts","./src/response-converter.ts","./src/http/index.ts","./src/http/run-fetch.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":"5.7.3"}