@pikku/lambda 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.8.0
+
+## 0.9.0
+
+### Breaking Changes
+
+- Normalized all transports to use "wirings" instead of events/routes/transports for consistency across the framework
+
+
+### Major Features
+
+- **SQS Queue Support**: Added SQS queue worker support
+
 ## 0.7.0
 
 - Updating to match remaining packages

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './http/index.js';
 export * from './websocket/index.js';
+export * from './queue/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,sBAAsB,CAAA;AACpC,cAAc,kBAAkB,CAAA"}

package/dist/queue/index.d.ts

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

package/dist/queue/index.js

@@ -0,0 +1,2 @@
+export { runSQSQueueWorker } from './sqs-worker.js';
+//# sourceMappingURL=index.js.map

package/dist/queue/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/queue/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/queue/sqs-worker.d.ts

@@ -0,0 +1,4 @@
+import { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
+import type { CoreSingletonServices, CreateSessionServices, QueueJob } from '@pikku/core';
+export declare function mapSQSRecordToQueueJob(record: SQSRecord, maxAttempts?: number): QueueJob;
+export declare const runSQSQueueWorker: (singletonServices: CoreSingletonServices, createSessionServices: CreateSessionServices<any, any, any> | undefined, event: SQSEvent) => Promise<SQSBatchResponse>;

package/dist/queue/sqs-worker.js

@@ -0,0 +1,59 @@
+import { runQueueJob } from '@pikku/core/queue';
+export function mapSQSRecordToQueueJob(record, maxAttempts) {
+    let data;
+    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 = {
+        queueName,
+        data,
+        id: record.messageId,
+        status: async () => 'active',
+        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;
+}
+export const runSQSQueueWorker = async (singletonServices, createSessionServices, event) => {
+    console.log(JSON.stringify(event, null, 2));
+    const jobs = event.Records.map(mapSQSRecordToQueueJob);
+    const results = await Promise.allSettled(jobs.map((job) => runQueueJob({
+        singletonServices,
+        createSessionServices,
+        job,
+    })));
+    results.forEach((result, index) => {
+        if (result.status === 'rejected') {
+            singletonServices.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 })),
+    };
+};
+//# sourceMappingURL=sqs-worker.js.map

package/dist/queue/sqs-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqs-worker.js","sourceRoot":"","sources":["../../src/queue/sqs-worker.ts"],"names":[],"mappings":"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"}

package/dist/websocket/lambda-eventhub-service.d.ts

@@ -1,14 +1,14 @@
 import { ChannelStore, EventHubService, EventHubStore } from '@pikku/core/channel';
 import { Logger } from '@pikku/core/services';
 import { APIGatewayEvent } from 'aws-lambda';
-export declare class LambdaEventHubService<Out = unknown> implements EventHubService<Out> {
+export declare class LambdaEventHubService<EventTopics extends Record<string, any> = {}> implements EventHubService<EventTopics> {
     private logger;
     private channelStore;
     private eventHubStore;
     private callbackAPI;
-    constructor(logger: Logger, event: APIGatewayEvent, channelStore: ChannelStore, eventHubStore: EventHubStore);
-    subscribe(topic: string, channelId: string): Promise<void>;
-    unsubscribe(topic: string, channelId: string): Promise<void>;
-    publish(topic: string, fromChannelId: string, data: Out, isBinary?: boolean): Promise<void>;
+    constructor(logger: Logger, event: APIGatewayEvent, channelStore: ChannelStore, eventHubStore: EventHubStore<EventTopics>);
+    subscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<void>;
+    unsubscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<void>;
+    publish<T extends keyof EventTopics>(topic: T, channelId: string | null, data: EventTopics[T], isBinary?: boolean): Promise<void>;
     private sendMessages;
 }

package/dist/websocket/lambda-eventhub-service.js

@@ -16,9 +16,11 @@ export class LambdaEventHubService {
     async unsubscribe(topic, channelId) {
         await this.eventHubStore.unsubscribe(topic, channelId);
     }
-    async publish(topic, fromChannelId, data, isBinary) {
+    async publish(topic, channelId, data, isBinary) {
         const channelIds = await this.eventHubStore.getChannelIdsForTopic(topic);
-        await this.sendMessages(channelIds, fromChannelId, data);
+        if (channelId) {
+            await this.sendMessages(channelIds, channelId, data, isBinary);
+        }
     }
     async sendMessages(channelIds, fromChannelId, data, isBinary) {
         await sendMessages(this.logger, this.channelStore, this.callbackAPI, fromChannelId, channelIds, data, isBinary);

package/dist/websocket/lambda-eventhub-service.js.map

@@ -1 +1 @@
-{"version":3,"file":"lambda-eventhub-service.js","sourceRoot":"","sources":["../../src/websocket/lambda-eventhub-service.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,gCAAgC,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAI3E,MAAM,OAAO,qBAAqB;IAMtB;IAEA;IACA;IANF,WAAW,CAA+B;IAElD,YACU,MAAc,EACtB,KAAsB,EACd,YAA0B,EAC1B,aAA4B;QAH5B,WAAM,GAAN,MAAM,CAAQ;QAEd,iBAAY,GAAZ,YAAY,CAAc;QAC1B,kBAAa,GAAb,aAAa,CAAe;QAEpC,IAAI,CAAC,WAAW,GAAG,gCAAgC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACpE,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,SAAiB;QAC9C,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IACtD,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,KAAa,EAAE,SAAiB;QAChD,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IACxD,CAAC;IAED,KAAK,CAAC,OAAO,CACX,KAAa,EACb,aAAqB,EACrB,IAAS,EACT,QAAkB;QAElB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAA;QACxE,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,aAAa,EAAE,IAAI,CAAC,CAAA;IAC1D,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,UAAoB,EACpB,aAAqB,EACrB,IAAS,EACT,QAAkB;QAElB,MAAM,YAAY,CAChB,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,WAAW,EAChB,aAAa,EACb,UAAU,EACV,IAAI,EACJ,QAAQ,CACT,CAAA;IACH,CAAC;CACF"}
+{"version":3,"file":"lambda-eventhub-service.js","sourceRoot":"","sources":["../../src/websocket/lambda-eventhub-service.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,gCAAgC,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAI3E,MAAM,OAAO,qBAAqB;IAMtB;IAEA;IACA;IANF,WAAW,CAA+B;IAElD,YACU,MAAc,EACtB,KAAsB,EACd,YAA0B,EAC1B,aAAyC;QAHzC,WAAM,GAAN,MAAM,CAAQ;QAEd,iBAAY,GAAZ,YAAY,CAAc;QAC1B,kBAAa,GAAb,aAAa,CAA4B;QAEjD,IAAI,CAAC,WAAW,GAAG,gCAAgC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IACpE,CAAC;IAED,KAAK,CAAC,SAAS,CACb,KAAQ,EACR,SAAiB;QAEjB,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IACtD,CAAC;IAED,KAAK,CAAC,WAAW,CACf,KAAQ,EACR,SAAiB;QAEjB,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;IACxD,CAAC;IAED,KAAK,CAAC,OAAO,CACX,KAAQ,EACR,SAAwB,EACxB,IAAoB,EACpB,QAAkB;QAElB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAC/D,KAAe,CAChB,CAAA;QACD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;QAChE,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,UAAoB,EACpB,aAAqB,EACrB,IAAoC,EACpC,QAAkB;QAElB,MAAM,YAAY,CAChB,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,WAAW,EAChB,aAAa,EACb,UAAU,EACV,IAAI,EACJ,QAAQ,CACT,CAAA;IACH,CAAC;CACF"}

package/dist/websocket/utils.d.ts

@@ -9,5 +9,5 @@ export declare const getServerlessDependencies: (logger: Logger, channelStore: C
     channelId: string;
     callbackAPI: ApiGatewayManagementApiClient;
     channelHandlerFactory: import("@pikku/core/channel").PikkuChannelHandlerFactory;
-    channelStore: ChannelStore<unknown, unknown, import("@pikku/core/dist/index.js").CoreUserSession, import("@pikku/core/channel").Channel<unknown, unknown>>;
+    channelStore: ChannelStore<unknown, unknown, import("@pikku/core/src/index.js").CoreUserSession, import("@pikku/core/channel").Channel<unknown, unknown>>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/lambda",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "license": "MIT",
   "author": "yasser.fadl@gmail.com",
   "module": "dist/index.js",
@@ -19,11 +19,12 @@
   "exports": {
     ".": "./dist/index.js",
     "./http": "./dist/http/index.js",
-    "./websocket": "./dist/websocket/index.js"
+    "./websocket": "./dist/websocket/index.js",
+    "./queue": "./dist/queue/index.js"
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.713.0",
-    "@pikku/core": "^0.7.0",
+    "@pikku/core": "^0.9.0",
     "@types/aws-lambda": "^8.10.146"
   },
   "devDependencies": {

package/src/http/index.ts

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

package/src/http/run-fetch.ts

@@ -0,0 +1,51 @@
+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

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

package/src/queue/index.ts

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

package/src/queue/sqs-worker.ts

@@ -0,0 +1,97 @@
+import { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda'
+import { runQueueJob } from '@pikku/core/queue'
+import type {
+  CoreSingletonServices,
+  CreateSessionServices,
+  QueueJob,
+  QueueJobStatus,
+} from '@pikku/core'
+
+/**
+ * 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 (
+  singletonServices: CoreSingletonServices,
+  createSessionServices: CreateSessionServices<any, any, any> | undefined,
+  event: SQSEvent
+): Promise<SQSBatchResponse> => {
+  console.log(JSON.stringify(event, null, 2))
+  const jobs = event.Records.map(mapSQSRecordToQueueJob)
+
+  // Process all jobs in parallel
+  const results = await Promise.allSettled(
+    jobs.map((job) =>
+      runQueueJob({
+        singletonServices,
+        createSessionServices,
+        job,
+      })
+    )
+  )
+
+  // Log any failures but don't throw (SQS will handle retries)
+  results.forEach((result, index) => {
+    if (result.status === 'rejected') {
+      singletonServices.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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,69 @@
+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<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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,17 @@
+{
+  "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

@@ -0,0 +1 @@
+{"root":["./src/index.ts","./src/request-converter.ts","./src/response-converter.ts","./src/http/index.ts","./src/http/run-fetch.ts","./src/queue/index.ts","./src/queue/sqs-worker.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.8.3"}