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

package/dist/lambda/integrations/index.js

@@ -0,0 +1,23 @@
+"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("./apigateway"), exports);
+__exportStar(require("./dynamodb"), exports);
+__exportStar(require("./eventbridge"), exports);
+__exportStar(require("./kinesis"), exports);
+__exportStar(require("./s3"), exports);
+__exportStar(require("./sns"), exports);
+__exportStar(require("./sqs"), exports);

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

@@ -0,0 +1,3 @@
+import { KinesisStreamEvent, KinesisStreamRecord } from 'aws-lambda';
+export declare const isKinesisRecord: (record: unknown) => record is KinesisStreamRecord;
+export declare const isKinesisEvent: (event: unknown) => event is KinesisStreamEvent;

package/dist/lambda/integrations/kinesis.js

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

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

@@ -0,0 +1,3 @@
+import { S3Event, S3EventRecord } from 'aws-lambda';
+export declare const isS3Record: (record: unknown) => record is S3EventRecord;
+export declare const isS3Event: (event: unknown) => event is S3Event;

package/dist/lambda/integrations/s3.js

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

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

@@ -0,0 +1,4 @@
+import { SNSEvent, SNSEventRecord, SNSMessage } from 'aws-lambda';
+export declare const isSnsMessage: (payload: unknown) => payload is SNSMessage;
+export declare const isSnsRecord: (record: unknown) => record is SNSEventRecord;
+export declare const isSnsEvent: (event: unknown) => event is SNSEvent;

package/dist/lambda/integrations/sns.js

@@ -0,0 +1,26 @@
+"use strict";
+// https://docs.aws.amazon.com/lambda/latest/dg/with-sns.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSnsEvent = exports.isSnsRecord = exports.isSnsMessage = void 0;
+const isSnsMessage = (payload) => {
+    return (payload !== null &&
+        typeof payload === 'object' &&
+        'Type' in payload &&
+        'TopicArn' in payload &&
+        typeof payload.TopicArn === 'string' &&
+        payload?.Type === 'Notification' &&
+        payload?.TopicArn?.startsWith('arn:aws:sns'));
+};
+exports.isSnsMessage = isSnsMessage;
+const isSnsRecord = (record) => {
+    return record !== null && typeof record === 'object' && 'EventSource' in record && record?.EventSource === 'aws:sns';
+};
+exports.isSnsRecord = isSnsRecord;
+const isSnsEvent = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'Records' in event &&
+        Array.isArray(event?.Records) &&
+        event.Records.every(exports.isSnsRecord));
+};
+exports.isSnsEvent = isSnsEvent;

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

@@ -0,0 +1,5 @@
+import { SNSMessage, SQSEvent, SQSRecord } from 'aws-lambda';
+export declare const isSqsRecord: (record: unknown) => record is SQSRecord;
+export declare const isSqsEvent: (event: unknown) => event is SQSEvent;
+export declare const tryUnwrapSnsMessageFromSqsRecord: (record: SQSRecord) => SNSMessage | never;
+export declare const isSqsRecordWithEmbeddedSnsMessage: (record: unknown) => record is SQSRecord;

package/dist/lambda/integrations/sqs.js

@@ -0,0 +1,38 @@
+"use strict";
+// https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSqsRecordWithEmbeddedSnsMessage = exports.tryUnwrapSnsMessageFromSqsRecord = exports.isSqsEvent = exports.isSqsRecord = void 0;
+const sns_1 = require("./sns");
+const isSqsRecord = (record) => {
+    return typeof record === 'object' && record !== null && 'eventSource' in record && record?.eventSource === 'aws:sqs';
+};
+exports.isSqsRecord = isSqsRecord;
+const isSqsEvent = (event) => {
+    return (event !== null &&
+        typeof event === 'object' &&
+        'Records' in event &&
+        Array.isArray(event?.Records) &&
+        event.Records.every(exports.isSqsRecord));
+};
+exports.isSqsEvent = isSqsEvent;
+const tryUnwrapSnsMessageFromSqsRecord = (record) => {
+    const parsedBody = JSON.parse(record.body);
+    if (!(0, sns_1.isSnsMessage)(parsedBody)) {
+        throw new Error('The SQS Record body is not a serialised SNS Message');
+    }
+    return parsedBody;
+};
+exports.tryUnwrapSnsMessageFromSqsRecord = tryUnwrapSnsMessageFromSqsRecord;
+const isSqsRecordWithEmbeddedSnsMessage = (record) => {
+    if (!(0, exports.isSqsRecord)(record)) {
+        return false;
+    }
+    try {
+        (0, exports.tryUnwrapSnsMessageFromSqsRecord)(record);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isSqsRecordWithEmbeddedSnsMessage = isSqsRecordWithEmbeddedSnsMessage;

package/dist/record-builders/api-gateway-request.builder.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'aws-lambda';
+import { OutgoingApiGatewayRequest, RequestBuilder } from '../interfaces';
+import { AnyAPIGatewayEvent } from '../lambda';
+export interface ApiGatewayPattern {
+    httpMethod: string;
+    resource: string;
+    queryStringParameters: Record<string, unknown> | null;
+    pathParameters: Record<string, unknown> | null;
+}
+export declare class ApiGatewayRequestBuilder implements RequestBuilder {
+    protected readonly data: AnyAPIGatewayEvent;
+    protected readonly context: Context;
+    static buildPattern(data: AnyAPIGatewayEvent): ApiGatewayPattern;
+    protected pattern: ApiGatewayPattern;
+    constructor(data: AnyAPIGatewayEvent, context: Context);
+    build(): OutgoingApiGatewayRequest;
+}

package/dist/record-builders/api-gateway-request.builder.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGatewayRequestBuilder = void 0;
+const lambda_1 = require("../lambda");
+class ApiGatewayRequestBuilder {
+    data;
+    context;
+    static buildPattern(data) {
+        if ((0, lambda_1.isApiGatewayEventV1)(data)) {
+            return {
+                httpMethod: data.httpMethod,
+                resource: data.resource,
+                queryStringParameters: data.queryStringParameters,
+                pathParameters: data.pathParameters,
+            };
+        }
+        if ((0, lambda_1.isApiGatewayEventV2)(data)) {
+            const [httpMethod, resource] = data.routeKey.split(' ');
+            return {
+                httpMethod: httpMethod,
+                resource: resource,
+                queryStringParameters: data.queryStringParameters ?? null,
+                pathParameters: data.pathParameters ?? null,
+            };
+        }
+        throw new Error('Unknown API Gateway event type');
+    }
+    pattern;
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+        this.pattern = ApiGatewayRequestBuilder.buildPattern(this.data);
+    }
+    build() {
+        return {
+            id: this.data.requestContext.requestId,
+            pattern: this.pattern,
+            data: this.data,
+            context: this.context,
+        };
+    }
+}
+exports.ApiGatewayRequestBuilder = ApiGatewayRequestBuilder;

package/dist/record-builders/api-gateway-response.builder.d.ts

@@ -0,0 +1,6 @@
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class ApiGatewayResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    constructor(responseTuples: ResponseTuple[]);
+    build(): unknown;
+}

package/dist/record-builders/api-gateway-response.builder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGatewayResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class ApiGatewayResponseBuilder {
+    responseTuples;
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        for (const [_request, response] of this.responseTuples) {
+            if (response instanceof errors_1.IncomingResponseError) {
+                throw response.cause;
+            }
+        }
+        if (this.responseTuples.length > 1) {
+            return this.responseTuples.map((tuple) => tuple[1]);
+        }
+        const tuple = this.responseTuples[0];
+        return tuple[1];
+    }
+}
+exports.ApiGatewayResponseBuilder = ApiGatewayResponseBuilder;

package/dist/record-builders/custom-request.builder.d.ts

@@ -0,0 +1,10 @@
+import { Context } from 'aws-lambda';
+import { OutgoingCustomRequest, RequestBuilder } from '../interfaces';
+export type CustomRecordPattern = '*';
+export declare class CustomRequestBuilder implements RequestBuilder {
+    protected readonly data: unknown;
+    protected readonly context: Context;
+    protected pattern: CustomRecordPattern;
+    constructor(data: unknown, context: Context);
+    build(): OutgoingCustomRequest;
+}

package/dist/record-builders/custom-request.builder.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomRequestBuilder = void 0;
+const uuid_1 = require("uuid");
+class CustomRequestBuilder {
+    data;
+    context;
+    pattern = '*';
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+    }
+    build() {
+        return {
+            id: (0, uuid_1.v4)(),
+            pattern: this.pattern,
+            data: this.data,
+            context: this.context,
+        };
+    }
+}
+exports.CustomRequestBuilder = CustomRequestBuilder;

package/dist/record-builders/custom-response.builder.d.ts

@@ -0,0 +1,6 @@
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class CustomResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    constructor(responseTuples: ResponseTuple[]);
+    build(): unknown;
+}

package/dist/record-builders/custom-response.builder.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class CustomResponseBuilder {
+    responseTuples;
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        for (const [_request, response] of this.responseTuples) {
+            if (response instanceof errors_1.IncomingResponseError) {
+                throw response.cause;
+            }
+        }
+        if (!this.responseTuples.length) {
+            return undefined;
+        }
+        if (this.responseTuples.length > 1) {
+            return this.responseTuples.map((tuple) => tuple[1]);
+        }
+        const tuple = this.responseTuples[0];
+        return tuple[1];
+    }
+}
+exports.CustomResponseBuilder = CustomResponseBuilder;

package/dist/record-builders/event-bridge-request.builder.d.ts

@@ -0,0 +1,16 @@
+import { Context } from 'aws-lambda';
+import { AnyEventBridgeEvent, JSONValue } from '../lambda';
+import { OutgoingEventBridgeRequest, RequestBuilder } from '../interfaces';
+export interface EventBridgePattern {
+    source: string;
+    detailType: string;
+    detail: JSONValue;
+}
+export declare class EventBridgeRequestBuilder implements RequestBuilder {
+    protected readonly data: AnyEventBridgeEvent;
+    protected readonly context: Context;
+    static buildPattern(data: AnyEventBridgeEvent): EventBridgePattern;
+    protected pattern: EventBridgePattern;
+    constructor(data: AnyEventBridgeEvent, context: Context);
+    build(): OutgoingEventBridgeRequest;
+}

package/dist/record-builders/event-bridge-request.builder.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgeRequestBuilder = void 0;
+class EventBridgeRequestBuilder {
+    data;
+    context;
+    static buildPattern(data) {
+        return {
+            source: data.source,
+            detailType: data['detail-type'],
+            detail: data.detail,
+        };
+    }
+    pattern;
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+        this.pattern = EventBridgeRequestBuilder.buildPattern(this.data);
+    }
+    build() {
+        return {
+            id: this.data.id,
+            pattern: this.pattern,
+            data: this.data,
+            context: this.context,
+        };
+    }
+}
+exports.EventBridgeRequestBuilder = EventBridgeRequestBuilder;

package/dist/record-builders/event-bridge-response.builder.d.ts

@@ -0,0 +1,6 @@
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class EventBridgeResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    constructor(responseTuples: ResponseTuple[]);
+    build(): unknown;
+}

package/dist/record-builders/event-bridge-response.builder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgeResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class EventBridgeResponseBuilder {
+    responseTuples;
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        for (const [_request, response] of this.responseTuples) {
+            if (response instanceof errors_1.IncomingResponseError) {
+                throw response.cause;
+            }
+        }
+        if (this.responseTuples.length > 1) {
+            return this.responseTuples.map((tuple) => tuple[1]);
+        }
+        const tuple = this.responseTuples[0];
+        return tuple[1];
+    }
+}
+exports.EventBridgeResponseBuilder = EventBridgeResponseBuilder;

package/dist/record-builders/index.d.ts

@@ -0,0 +1,12 @@
+export * from './api-gateway-request.builder';
+export * from './api-gateway-response.builder';
+export * from './custom-request.builder';
+export * from './custom-response.builder';
+export * from './event-bridge-request.builder';
+export * from './event-bridge-response.builder';
+export * from './s3-request.builder';
+export * from './s3-response.builder';
+export * from './sns-request.builder';
+export * from './sns-response.builder';
+export * from './sqs-request.builder';
+export * from './sqs-response.builder';

package/dist/record-builders/index.js

@@ -0,0 +1,28 @@
+"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("./api-gateway-request.builder"), exports);
+__exportStar(require("./api-gateway-response.builder"), exports);
+__exportStar(require("./custom-request.builder"), exports);
+__exportStar(require("./custom-response.builder"), exports);
+__exportStar(require("./event-bridge-request.builder"), exports);
+__exportStar(require("./event-bridge-response.builder"), exports);
+__exportStar(require("./s3-request.builder"), exports);
+__exportStar(require("./s3-response.builder"), exports);
+__exportStar(require("./sns-request.builder"), exports);
+__exportStar(require("./sns-response.builder"), exports);
+__exportStar(require("./sqs-request.builder"), exports);
+__exportStar(require("./sqs-response.builder"), exports);

package/dist/record-builders/s3-request.builder.d.ts

@@ -0,0 +1,15 @@
+import { Context, S3EventRecord } from 'aws-lambda';
+import { OutgoingS3Request, RequestBuilder } from '../interfaces';
+export interface S3RecordPattern {
+    eventName: string;
+    bucketName: string;
+    objectKey: string;
+}
+export declare class S3RequestBuilder implements RequestBuilder {
+    protected readonly data: S3EventRecord;
+    protected readonly context: Context;
+    static buildPattern(data: S3EventRecord): S3RecordPattern;
+    protected pattern: S3RecordPattern;
+    constructor(data: S3EventRecord, context: Context);
+    build(): OutgoingS3Request;
+}

package/dist/record-builders/s3-request.builder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3RequestBuilder = void 0;
+const uuid_1 = require("uuid");
+class S3RequestBuilder {
+    data;
+    context;
+    static buildPattern(data) {
+        return {
+            eventName: data.eventName,
+            bucketName: data.s3.bucket.name,
+            objectKey: data.s3.object.key,
+        };
+    }
+    pattern;
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+        this.pattern = S3RequestBuilder.buildPattern(this.data);
+    }
+    build() {
+        return {
+            id: (0, uuid_1.v4)(),
+            pattern: this.pattern,
+            data: this.data,
+            context: this.context,
+        };
+    }
+}
+exports.S3RequestBuilder = S3RequestBuilder;

package/dist/record-builders/s3-response.builder.d.ts

@@ -0,0 +1,6 @@
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class S3ResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    constructor(responseTuples: ResponseTuple[]);
+    build(): unknown[];
+}

package/dist/record-builders/s3-response.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3ResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class S3ResponseBuilder {
+    responseTuples;
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        for (const [_request, response] of this.responseTuples) {
+            if (response instanceof errors_1.IncomingResponseError) {
+                throw response.cause;
+            }
+        }
+        return this.responseTuples.map(([_request, response]) => response);
+    }
+}
+exports.S3ResponseBuilder = S3ResponseBuilder;

package/dist/record-builders/sns-request.builder.d.ts

@@ -0,0 +1,16 @@
+import { Context, SNSMessage, SNSMessageAttribute } from 'aws-lambda';
+import { SNSEventRecord } from 'aws-lambda/trigger/sns';
+import { OutgoingSnsRequest, RequestBuilder } from '../interfaces';
+export interface SnsRecordPattern {
+    [key: string]: string | number;
+}
+export declare class SnsRequestBuilder implements RequestBuilder {
+    protected readonly data: SNSEventRecord;
+    protected readonly context: Context;
+    static buildPattern(data: SNSEventRecord): SnsRecordPattern;
+    static buildSnsMessagePattern(data: SNSMessage): SnsRecordPattern;
+    static mapSnsMessageAttributes(messageAttribute: SNSMessageAttribute): string | number;
+    protected pattern: SnsRecordPattern;
+    constructor(data: SNSEventRecord, context: Context);
+    build(): OutgoingSnsRequest;
+}

package/dist/record-builders/sns-request.builder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsRequestBuilder = void 0;
+class SnsRequestBuilder {
+    data;
+    context;
+    static buildPattern(data) {
+        return SnsRequestBuilder.buildSnsMessagePattern(data.Sns);
+    }
+    static buildSnsMessagePattern(data) {
+        const pattern = {};
+        const messageAttrs = data.MessageAttributes;
+        return Reflect.ownKeys(messageAttrs).reduce((pattern, key) => {
+            Reflect.set(pattern, key, SnsRequestBuilder.mapSnsMessageAttributes(Reflect.get(messageAttrs, key)));
+            return pattern;
+        }, pattern);
+    }
+    static mapSnsMessageAttributes(messageAttribute) {
+        switch (messageAttribute.Type) {
+            case 'String':
+                try {
+                    return messageAttribute.Value ? JSON.parse(messageAttribute.Value) : '';
+                }
+                catch (_error) {
+                    return messageAttribute.Value ?? '';
+                }
+            case 'String.Array':
+                return messageAttribute.Value ? JSON.parse(messageAttribute.Value) : [];
+            case 'Number':
+                return messageAttribute.Value ? JSON.parse(messageAttribute.Value) : 0;
+            case 'Binary':
+            default:
+                throw new Error('Attribute type not implemented');
+        }
+    }
+    pattern = {};
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+        this.pattern = SnsRequestBuilder.buildPattern(this.data);
+    }
+    build() {
+        return {
+            id: this.data.Sns.MessageId,
+            pattern: this.pattern,
+            data: this.data.Sns,
+            context: this.context,
+        };
+    }
+}
+exports.SnsRequestBuilder = SnsRequestBuilder;

package/dist/record-builders/sns-response.builder.d.ts

@@ -0,0 +1,6 @@
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class SnsResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    constructor(responseTuples: ResponseTuple[]);
+    build(): unknown[];
+}

package/dist/record-builders/sns-response.builder.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnsResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class SnsResponseBuilder {
+    responseTuples;
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        for (const [_request, response] of this.responseTuples) {
+            if (response instanceof errors_1.IncomingResponseError) {
+                throw response.cause;
+            }
+        }
+        return this.responseTuples.map(([_request, response]) => response);
+    }
+}
+exports.SnsResponseBuilder = SnsResponseBuilder;

package/dist/record-builders/sqs-request.builder.d.ts

@@ -0,0 +1,16 @@
+import { Context, SQSRecord } from 'aws-lambda';
+import { SQSMessageAttribute } from 'aws-lambda/trigger/sqs';
+import { OutgoingSqsRequest, RequestBuilder } from '../interfaces';
+export interface SqsRecordPattern {
+    [key: string]: string | number;
+}
+export declare class SqsRequestBuilder implements RequestBuilder {
+    protected readonly data: SQSRecord;
+    protected readonly context: Context;
+    static buildPattern(data: SQSRecord): SqsRecordPattern;
+    static buildSqsMessagePattern(data: SQSRecord): SqsRecordPattern;
+    static mapSqsMessageAttributes(messageAttribute: SQSMessageAttribute): string | number;
+    protected pattern: SqsRecordPattern;
+    constructor(data: SQSRecord, context: Context);
+    build(): OutgoingSqsRequest;
+}