@klarna/nest-lambda-microservice 0.1.0-beta.0

package/dist/client/lambda-microservice.client.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaMicroserviceClient = exports.ClientToken = void 0;
+const microservices_1 = require("@nestjs/microservices");
+const rxjs_1 = require("rxjs");
+const uuid_1 = require("uuid");
+const errors_1 = require("../errors");
+const lambda_1 = require("../lambda");
+exports.ClientToken = Symbol('LambdaMicroserviceClient');
+class LambdaMicroserviceClient extends microservices_1.ClientProxy {
+    broker;
+    eventMapper = new lambda_1.EventMapper();
+    requestMap = new WeakMap();
+    isConnected = false;
+    constructor(options) {
+        super();
+        this.broker = options.broker;
+        this.initializeSerializer(options);
+        this.initializeDeserializer(options);
+    }
+    async close() {
+        if (this.isConnected) {
+            this.isConnected = false;
+        }
+    }
+    async connect() {
+        if (!this.isConnected) {
+            this.isConnected = true;
+        }
+    }
+    async processEvent(event, context) {
+        const request = this.eventMapper.mapEventToRequest(event, context);
+        const requests = Array.isArray(request) ? request : [request];
+        return new Promise((resolve, reject) => {
+            const merged$ = (0, rxjs_1.merge)(...requests.map((outgoingRequest) => {
+                this.requestMap.set(outgoingRequest.data, outgoingRequest);
+                return this.send(outgoingRequest.pattern, outgoingRequest.data)
+                    .pipe((0, rxjs_1.catchError)((err) => (0, rxjs_1.of)(new errors_1.IncomingResponseError(outgoingRequest.id, err))))
+                    .pipe((0, rxjs_1.map)((incomingResponse) => [
+                    outgoingRequest,
+                    incomingResponse,
+                ]));
+            }));
+            merged$
+                .pipe((0, rxjs_1.reduce)((acc, responseTuple) => {
+                return [...acc, responseTuple];
+            }, []))
+                .subscribe((responseTuplesList) => {
+                try {
+                    resolve(this.eventMapper.mapToLambdaResponse(event, responseTuplesList));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    publish(partialPacket, callbackFn) {
+        const packet = this.assignPacketId(partialPacket);
+        const producerUnsubscribeCallback = () => {
+            this.routingMap.delete(packet.id);
+        };
+        this.routingMap.set(packet.id, callbackFn);
+        try {
+            const context = this.requestMap.get(packet.data)?.context;
+            const serializedPacket = this.serializer.serialize(packet);
+            const responseCallback = this.createResponseCallback();
+            const responseStream$ = this.broker.sendRequest({ ...serializedPacket, context });
+            const responseSubscription = responseStream$.subscribe({ next: responseCallback });
+            return () => {
+                responseSubscription.unsubscribe();
+                producerUnsubscribeCallback();
+            };
+        }
+        catch (err) {
+            callbackFn({ err });
+        }
+        return producerUnsubscribeCallback;
+    }
+    assignPacketId(packet) {
+        const incomingRequest = this.requestMap.get(packet.data);
+        const id = incomingRequest?.id ?? (0, uuid_1.v4)();
+        return Object.assign(packet, { id });
+    }
+    dispatchEvent(_packet) {
+        throw new Error('The dispatchEvent is not implemented in Lambda Microservice');
+    }
+    createResponseCallback() {
+        return async (incomingResponse) => {
+            const { id, err, response, isDisposed } = await this.deserializer.deserialize(incomingResponse);
+            const callbackFn = this.routingMap.get(id);
+            if (!callbackFn) {
+                return;
+            }
+            if (isDisposed || err) {
+                return callbackFn({ err, response, isDisposed: true });
+            }
+            callbackFn({ err, response });
+        };
+    }
+}
+exports.LambdaMicroserviceClient = LambdaMicroserviceClient;

package/dist/ctx-host/index.d.ts

@@ -0,0 +1 @@
+export * from './lambda.context';

package/dist/ctx-host/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lambda.context"), exports);

package/dist/ctx-host/lambda.context.d.ts

@@ -0,0 +1,10 @@
+import { BaseRpcContext } from '@nestjs/microservices';
+import { LoggerService } from '@nestjs/common/services/logger.service';
+import { Context } from 'aws-lambda';
+export type LambdaContextArgs = [context: Context];
+export declare class LambdaContext<T extends LoggerService> extends BaseRpcContext<LambdaContextArgs> {
+    protected logger?: T;
+    getLambdaInvocationContext(): Context;
+    setLogger(logger: T): this;
+    getLogger(): T | void;
+}

package/dist/ctx-host/lambda.context.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaContext = void 0;
+const microservices_1 = require("@nestjs/microservices");
+class LambdaContext extends microservices_1.BaseRpcContext {
+    logger;
+    getLambdaInvocationContext() {
+        return this.args[0];
+    }
+    setLogger(logger) {
+        this.logger = logger;
+        return this;
+    }
+    getLogger() {
+        return this.logger;
+    }
+}
+exports.LambdaContext = LambdaContext;

package/dist/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './use-partial-pattern-match';

package/dist/decorators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./use-partial-pattern-match"), exports);

package/dist/decorators/use-partial-pattern-match.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Decorator that marks all controller methods decorated with @MessagePattern decorator as eligible for partial match
+ * @example The below snippet
+ * ```
+ * @Controller()
+ * class Controller {
+ *   @MessagePattern({ foo: 'bar' }, { partialMatch: true })
+ *   public method() {}
+ * }
+ * ```
+ * has same effects as
+ * ```
+ * @Controller()
+ * @UsePartialPatternMatch()
+ * class Controller {
+ *   @MessagePattern({ foo: 'bar' })
+ *   public method() {}
+ * }
+ * ```
+ */
+export declare function UsePartialPatternMatch(): ClassDecorator;

package/dist/decorators/use-partial-pattern-match.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsePartialPatternMatch = void 0;
+const constants_1 = require("@nestjs/microservices/constants");
+const server_1 = require("../server");
+const getClassMethods = (target) => {
+    const ret = new Set();
+    function methods(obj) {
+        if (obj !== null && typeof obj === 'object') {
+            const ps = Object.getOwnPropertyNames(obj);
+            ps.forEach((p) => {
+                const value = Reflect.get(obj, p);
+                if (value instanceof Function && Reflect.hasMetadata(constants_1.PATTERN_METADATA, value)) {
+                    ret.add(value);
+                }
+            });
+            methods(Object.getPrototypeOf(obj));
+        }
+    }
+    if (target !== null && typeof target === 'function' && 'prototype' in target) {
+        methods(target.prototype);
+    }
+    return Array.from(ret);
+};
+/**
+ * Decorator that marks all controller methods decorated with @MessagePattern decorator as eligible for partial match
+ * @example The below snippet
+ * ```
+ * @Controller()
+ * class Controller {
+ *   @MessagePattern({ foo: 'bar' }, { partialMatch: true })
+ *   public method() {}
+ * }
+ * ```
+ * has same effects as
+ * ```
+ * @Controller()
+ * @UsePartialPatternMatch()
+ * class Controller {
+ *   @MessagePattern({ foo: 'bar' })
+ *   public method() {}
+ * }
+ * ```
+ */
+function UsePartialPatternMatch() {
+    return (target) => {
+        for (const method of getClassMethods(target)) {
+            const extrasMetadata = Reflect.getMetadata(constants_1.PATTERN_EXTRAS_METADATA, method) ?? {};
+            Reflect.defineMetadata(constants_1.PATTERN_EXTRAS_METADATA, { [server_1.PartialMatchExtraProp]: true, ...extrasMetadata }, method);
+        }
+    };
+}
+exports.UsePartialPatternMatch = UsePartialPatternMatch;

package/dist/errors/IncomingResponseError.d.ts

@@ -0,0 +1,6 @@
+export declare class IncomingResponseError extends Error {
+    readonly requestId: string;
+    readonly cause: unknown;
+    constructor(requestId: string, cause: unknown);
+    protected trySerializeCause(cause: unknown): string;
+}

package/dist/errors/IncomingResponseError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncomingResponseError = void 0;
+class IncomingResponseError extends Error {
+    requestId;
+    cause;
+    constructor(requestId, cause) {
+        super(`The server failed to process the request`);
+        this.requestId = requestId;
+        this.cause = cause;
+        this.message = `${this.message}, cause: ${this.trySerializeCause(cause)}`;
+    }
+    trySerializeCause(cause) {
+        try {
+            if (cause instanceof Error) {
+                return JSON.stringify(cause, Object.getOwnPropertyNames(cause));
+            }
+            return JSON.stringify(cause);
+        }
+        catch (_error) {
+            return `${cause}`;
+        }
+    }
+}
+exports.IncomingResponseError = IncomingResponseError;

package/dist/errors/NoConsumerError.d.ts

@@ -0,0 +1,3 @@
+export declare class NoConsumerError extends Error {
+    constructor();
+}

package/dist/errors/NoConsumerError.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoConsumerError = void 0;
+class NoConsumerError extends Error {
+    constructor() {
+        super('No consumer is currently connected to the broker. The messages emitted by the client will be lost.');
+    }
+}
+exports.NoConsumerError = NoConsumerError;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IncomingResponseError';
+export * from './NoConsumerError';

package/dist/errors/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IncomingResponseError"), exports);
+__exportStar(require("./NoConsumerError"), exports);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './client';
+export * from './ctx-host';
+export * from './decorators';
+export * from './errors';
+export * from './lambda';
+export * from './interfaces';
+export * from './record-builders';
+export * from './server';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./ctx-host"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./lambda"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./record-builders"), exports);
+__exportStar(require("./server"), exports);

package/dist/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lambda-microservice.config';
+export * from './lambda-microservice.packet';
+export * from './request.builder';
+export * from './response.builder';

package/dist/interfaces/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lambda-microservice.config"), exports);
+__exportStar(require("./lambda-microservice.packet"), exports);
+__exportStar(require("./request.builder"), exports);
+__exportStar(require("./response.builder"), exports);

package/dist/interfaces/lambda-microservice.config.d.ts

@@ -0,0 +1,9 @@
+import { CustomClientOptions } from '@nestjs/microservices';
+import { LambdaMicroserviceClient } from '../client';
+import { LambdaMicroserviceBroker } from '../server';
+export interface LambdaMicroserviceOptions extends CustomClientOptions {
+    customClass: typeof LambdaMicroserviceClient;
+    options: {
+        broker: LambdaMicroserviceBroker;
+    };
+}

package/dist/interfaces/lambda-microservice.config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/lambda-microservice.packet.d.ts

@@ -0,0 +1,35 @@
+import { ReadPacket, WritePacket, PacketId } from '@nestjs/microservices';
+import { Context, SNSMessage, SQSRecord, S3EventRecord, EventBridgeEvent, APIGatewayEvent, APIGatewayProxyEventV2 } from 'aws-lambda';
+import { IncomingResponseError } from '../errors';
+export interface ContextAware {
+    context: Context;
+}
+export type OutgoingCustomRequest = ReadPacket & PacketId & ContextAware;
+export type IncomingCustomRequest = ReadPacket & PacketId & ContextAware;
+export type OutgoingCustomResponse = WritePacket & PacketId;
+export type IncomingCustomResponse = WritePacket & PacketId;
+export type OutgoingSqsRequest = ReadPacket<SQSRecord> & PacketId & ContextAware;
+export type IncomingSqsRequest = ReadPacket<SQSRecord> & PacketId & ContextAware;
+export type OutgoingSqsResponse = WritePacket<void> & PacketId;
+export type IncomingSqsResponse = WritePacket<void> & PacketId;
+export type OutgoingSnsRequest = ReadPacket<SNSMessage> & PacketId & ContextAware;
+export type IncomingSnsRequest = ReadPacket<SNSMessage> & PacketId & ContextAware;
+export type OutgoingSnsResponse = WritePacket<void> & PacketId;
+export type IncomingSnsResponse = WritePacket<void> & PacketId;
+export type OutgoingS3Request = ReadPacket<S3EventRecord> & PacketId & ContextAware;
+export type IncomingS3Request = ReadPacket<S3EventRecord> & PacketId & ContextAware;
+export type OutgoingS3Response = WritePacket<void> & PacketId;
+export type IncomingS3Response = WritePacket<void> & PacketId;
+export type OutgoingEventBridgeRequest = ReadPacket<EventBridgeEvent<string, unknown>> & PacketId & ContextAware;
+export type IncomingEventBridgeRequest = ReadPacket<EventBridgeEvent<string, unknown>> & PacketId & ContextAware;
+export type OutgoingEventBridgeResponse = WritePacket<void> & PacketId;
+export type IncomingEventBridgeResponse = WritePacket<void> & PacketId;
+export type OutgoingApiGatewayRequest = ReadPacket<APIGatewayEvent | APIGatewayProxyEventV2> & PacketId & ContextAware;
+export type IncomingApiGatewayRequest = ReadPacket<APIGatewayEvent | APIGatewayProxyEventV2> & PacketId & ContextAware;
+export type OutgoingApiGatewayResponse = WritePacket<void> & PacketId;
+export type IncomingApiGatewayResponse = WritePacket<void> & PacketId;
+export type OutgoingRequest = OutgoingCustomRequest | OutgoingSqsRequest | OutgoingSnsRequest;
+export type IncomingRequest = IncomingCustomRequest | IncomingSqsRequest | IncomingSnsRequest;
+export type OutgoingResponse = OutgoingCustomResponse | OutgoingSqsResponse | OutgoingSnsResponse;
+export type IncomingResponse = IncomingCustomResponse | IncomingSqsResponse | IncomingSnsResponse;
+export type ResponseTuple = [OutgoingRequest, unknown | IncomingResponseError];

package/dist/interfaces/lambda-microservice.packet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/request.builder.d.ts

@@ -0,0 +1,4 @@
+import { OutgoingRequest } from './lambda-microservice.packet';
+export interface RequestBuilder {
+    build(): OutgoingRequest;
+}

package/dist/interfaces/request.builder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/response.builder.d.ts

@@ -0,0 +1,3 @@
+export interface ResponseBuilder {
+    build(): unknown;
+}

package/dist/interfaces/response.builder.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lambda/event-mapper.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'aws-lambda';
+import { OutgoingRequest, ResponseTuple } from '../interfaces';
+export declare class EventMapper {
+    mapEventToRequest(event: unknown, context: Context): OutgoingRequest | OutgoingRequest[];
+    mapToLambdaResponse(event: unknown, responseTuples: ResponseTuple[]): unknown;
+    protected throwNotImplementedError(eventType: string): void;
+}

package/dist/lambda/event-mapper.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventMapper = void 0;
+const microservices_1 = require("@nestjs/microservices");
+const record_builders_1 = require("../record-builders");
+const integrations_1 = require("./integrations");
+class EventMapper {
+    mapEventToRequest(event, context) {
+        if ((0, integrations_1.isApiGatewayEvent)(event)) {
+            return new record_builders_1.ApiGatewayRequestBuilder(event, context).build();
+        }
+        if ((0, integrations_1.isEventBridgeEvent)(event)) {
+            return new record_builders_1.EventBridgeRequestBuilder(event, context).build();
+        }
+        if ((0, integrations_1.isS3Event)(event)) {
+            return event.Records.map((record) => {
+                return new record_builders_1.S3RequestBuilder(record, context).build();
+            });
+        }
+        if ((0, integrations_1.isSnsEvent)(event)) {
+            return event.Records.map((record) => {
+                return new record_builders_1.SnsRequestBuilder(record, context).build();
+            });
+        }
+        if ((0, integrations_1.isSqsEvent)(event)) {
+            return event.Records.map((record) => {
+                return new record_builders_1.SqsRequestBuilder(record, context).build();
+            });
+        }
+        return new record_builders_1.CustomRequestBuilder(event, context).build();
+    }
+    mapToLambdaResponse(event, responseTuples) {
+        if ((0, integrations_1.isApiGatewayEvent)(event)) {
+            return new record_builders_1.ApiGatewayResponseBuilder(responseTuples).build();
+        }
+        if ((0, integrations_1.isEventBridgeEvent)(event)) {
+            return new record_builders_1.EventBridgeResponseBuilder(responseTuples).build();
+        }
+        if ((0, integrations_1.isS3Event)(event)) {
+            return new record_builders_1.S3ResponseBuilder(responseTuples).build();
+        }
+        if ((0, integrations_1.isSnsEvent)(event)) {
+            return new record_builders_1.SnsResponseBuilder(responseTuples).build();
+        }
+        if ((0, integrations_1.isSqsEvent)(event)) {
+            return new record_builders_1.SqsResponseBuilder(responseTuples).build();
+        }
+        return new record_builders_1.CustomResponseBuilder(responseTuples).build();
+    }
+    throwNotImplementedError(eventType) {
+        throw new microservices_1.RpcException(`Event source ${eventType} not implemented`);
+    }
+}
+exports.EventMapper = EventMapper;

package/dist/lambda/index.d.ts

@@ -0,0 +1,2 @@
+export * from './integrations';
+export * from './event-mapper';

package/dist/lambda/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./integrations"), exports);
+__exportStar(require("./event-mapper"), exports);

package/dist/lambda/integrations/apigateway.d.ts

@@ -0,0 +1,5 @@
+import { APIGatewayEvent, APIGatewayProxyEventV2 } from 'aws-lambda';
+export type AnyAPIGatewayEvent = APIGatewayEvent | APIGatewayProxyEventV2;
+export declare const isApiGatewayEvent: (event: unknown) => event is AnyAPIGatewayEvent;
+export declare const isApiGatewayEventV1: (event: unknown) => event is import("aws-lambda").APIGatewayProxyEvent;
+export declare const isApiGatewayEventV2: (event: unknown) => event is APIGatewayProxyEventV2;

package/dist/lambda/integrations/apigateway.js

@@ -0,0 +1,26 @@
+"use strict";
+// https://docs.aws.amazon.com/lambda/latest/dg/services-apigateway.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isApiGatewayEventV2 = exports.isApiGatewayEventV1 = exports.isApiGatewayEvent = void 0;
+const isApiGatewayEvent = (event) => {
+    return (0, exports.isApiGatewayEventV1)(event) || (0, exports.isApiGatewayEventV2)(event);
+};
+exports.isApiGatewayEvent = isApiGatewayEvent;
+const isApiGatewayEventV1 = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'requestContext' in event &&
+        'httpMethod' in event &&
+        'path' in event &&
+        'isBase64Encoded' in event);
+};
+exports.isApiGatewayEventV1 = isApiGatewayEventV1;
+const isApiGatewayEventV2 = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'requestContext' in event &&
+        'routeKey' in event &&
+        'rawPath' in event &&
+        'isBase64Encoded' in event);
+};
+exports.isApiGatewayEventV2 = isApiGatewayEventV2;

package/dist/lambda/integrations/dynamodb.d.ts

@@ -0,0 +1,3 @@
+import { DynamoDBRecord, DynamoDBStreamEvent } from 'aws-lambda';
+export declare const isDynamoDbRecord: (record: unknown) => record is DynamoDBRecord;
+export declare const isDynamoDbEvent: (event: unknown) => event is DynamoDBStreamEvent;

package/dist/lambda/integrations/dynamodb.js

@@ -0,0 +1,16 @@
+"use strict";
+// https://docs.aws.amazon.com/lambda/latest/dg/with-ddb.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamoDbEvent = exports.isDynamoDbRecord = void 0;
+const isDynamoDbRecord = (record) => {
+    return (record !== null && typeof record === 'object' && 'eventSource' in record && record?.eventSource === 'aws:dynamodb');
+};
+exports.isDynamoDbRecord = isDynamoDbRecord;
+const isDynamoDbEvent = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'Records' in event &&
+        Array.isArray(event?.Records) &&
+        event.Records.every(exports.isDynamoDbRecord));
+};
+exports.isDynamoDbEvent = isDynamoDbEvent;

package/dist/lambda/integrations/eventbridge.d.ts

@@ -0,0 +1,10 @@
+import { EventBridgeEvent } from 'aws-lambda';
+export { EventBridgeEvent } from 'aws-lambda';
+export type JSONValue = string | number | boolean | JSONObject | JSONArray | Record<never, never>;
+interface JSONObject {
+    [x: string]: JSONValue;
+}
+type JSONArray = Array<JSONValue>;
+export type AnyEventBridgeEvent = EventBridgeEvent<string, JSONValue>;
+export type EventBridgeCronEvent = EventBridgeEvent<'Scheduled Event', Record<string, unknown>>;
+export declare const isEventBridgeEvent: (event: unknown) => event is AnyEventBridgeEvent;

package/dist/lambda/integrations/eventbridge.js

@@ -0,0 +1,13 @@
+"use strict";
+// https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEventBridgeEvent = void 0;
+const isEventBridgeEvent = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'source' in event &&
+        typeof event.source === 'string' &&
+        'detail-type' in event &&
+        typeof event['detail-type'] === 'string');
+};
+exports.isEventBridgeEvent = isEventBridgeEvent;

package/dist/lambda/integrations/index.d.ts

@@ -0,0 +1,7 @@
+export * from './apigateway';
+export * from './dynamodb';
+export * from './eventbridge';
+export * from './kinesis';
+export * from './s3';
+export * from './sns';
+export * from './sqs';