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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsRequestBuilder = void 0;
+const lambda_1 = require("../lambda");
+const sns_request_builder_1 = require("./sns-request.builder");
+class SqsRequestBuilder {
+    data;
+    context;
+    static buildPattern(data) {
+        try {
+            const snsMessage = (0, lambda_1.tryUnwrapSnsMessageFromSqsRecord)(data);
+            return sns_request_builder_1.SnsRequestBuilder.buildSnsMessagePattern(snsMessage);
+        }
+        catch (_error) {
+            return SqsRequestBuilder.buildSqsMessagePattern(data);
+        }
+    }
+    static buildSqsMessagePattern(data) {
+        const pattern = {};
+        const messageAttrs = data.messageAttributes;
+        return Reflect.ownKeys(messageAttrs).reduce((pattern, key) => {
+            Reflect.set(pattern, key, SqsRequestBuilder.mapSqsMessageAttributes(Reflect.get(messageAttrs, key)));
+            return pattern;
+        }, pattern);
+    }
+    static mapSqsMessageAttributes(messageAttribute) {
+        switch (messageAttribute.dataType) {
+            case 'String':
+                try {
+                    return messageAttribute.stringValue ? JSON.parse(messageAttribute.stringValue) : '';
+                }
+                catch (_error) {
+                    return messageAttribute.stringValue ?? '';
+                }
+            case 'Number':
+                return messageAttribute.stringValue ? JSON.parse(messageAttribute.stringValue) : 0;
+            case 'Binary':
+            default:
+                throw new Error('Attribute type not implemented');
+        }
+    }
+    pattern = {};
+    constructor(data, context) {
+        this.data = data;
+        this.context = context;
+        this.pattern = SqsRequestBuilder.buildPattern(this.data);
+    }
+    build() {
+        return {
+            id: this.data.messageId,
+            pattern: this.pattern,
+            data: this.data,
+            context: this.context,
+        };
+    }
+}
+exports.SqsRequestBuilder = SqsRequestBuilder;

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

@@ -0,0 +1,11 @@
+import { SQSBatchItemFailure } from 'aws-lambda/trigger/sqs';
+import { ResponseBuilder, ResponseTuple } from '../interfaces';
+export declare class SqsResponseBuilder implements ResponseBuilder {
+    protected readonly responseTuples: ResponseTuple[];
+    static isSQSBatchItemFailure: (item: unknown) => item is SQSBatchItemFailure;
+    static responseCompareFn: (a: SQSBatchItemFailure, b: SQSBatchItemFailure) => number;
+    constructor(responseTuples: ResponseTuple[]);
+    build(): {
+        batchItemFailures: SQSBatchItemFailure[];
+    };
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsResponseBuilder = void 0;
+const errors_1 = require("../errors");
+class SqsResponseBuilder {
+    responseTuples;
+    static isSQSBatchItemFailure = (item) => typeof item === 'object' && item !== null && 'itemIdentifier' in item && Boolean(item?.itemIdentifier);
+    static responseCompareFn = (a, b) => (a?.itemIdentifier ?? '').localeCompare(b?.itemIdentifier ?? '');
+    constructor(responseTuples) {
+        this.responseTuples = responseTuples;
+    }
+    build() {
+        // https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-batchfailurereporting
+        return {
+            batchItemFailures: this.responseTuples
+                .map(([request, response]) => ({
+                itemIdentifier: response instanceof errors_1.IncomingResponseError ? request.id : null,
+            }))
+                .filter(SqsResponseBuilder.isSQSBatchItemFailure)
+                .sort(SqsResponseBuilder.responseCompareFn),
+        };
+    }
+}
+exports.SqsResponseBuilder = SqsResponseBuilder;

package/dist/server/__mocks__/index.d.ts

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

package/dist/server/__mocks__/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-microservice.broker"), exports);

package/dist/server/__mocks__/lambda-microservice.broker.d.ts

@@ -0,0 +1,11 @@
+import { MockedObject } from 'jest-mock';
+import { LambdaMicroserviceBroker } from '../lambda-microservice.broker';
+export declare const sendRequest: import("jest-mock").Mock<any>;
+export declare const on: import("jest-mock").Mock<any>;
+export declare const emit: import("jest-mock").Mock<any>;
+export declare const once: import("jest-mock").Mock<any>;
+export declare const off: import("jest-mock").Mock<any>;
+export declare const listen: import("jest-mock").Mock<any>;
+export declare const close: import("jest-mock").Mock<any>;
+export declare const mockServerResponse: (requestId: string, response: unknown) => void;
+export declare const LambdaMicroserviceBrokerFactory: () => MockedObject<LambdaMicroserviceBroker>;

package/dist/server/__mocks__/lambda-microservice.broker.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaMicroserviceBrokerFactory = exports.mockServerResponse = exports.close = exports.listen = exports.off = exports.once = exports.emit = exports.on = exports.sendRequest = void 0;
+const jest_mock_1 = require("jest-mock");
+const rxjs_1 = require("rxjs");
+const globals_1 = require("@jest/globals");
+exports.sendRequest = globals_1.jest.fn();
+exports.on = globals_1.jest.fn();
+exports.emit = globals_1.jest.fn();
+exports.once = globals_1.jest.fn();
+exports.off = globals_1.jest.fn();
+exports.listen = globals_1.jest.fn().mockImplementation((cb) => cb && cb());
+exports.close = globals_1.jest.fn().mockImplementation((cb) => cb && cb());
+const mockServerResponse = (requestId, response) => {
+    exports.sendRequest.mockImplementationOnce(() => {
+        const subject = new rxjs_1.ReplaySubject();
+        subject.next({
+            id: requestId,
+            response: response instanceof Error ? undefined : response,
+            err: response instanceof Error ? response : undefined,
+            isDisposed: true,
+        });
+        subject.complete();
+        return subject;
+    });
+};
+exports.mockServerResponse = mockServerResponse;
+const LambdaMicroserviceBrokerFactory = () => (0, jest_mock_1.mocked)({
+    listen: exports.listen,
+    close: exports.close,
+    sendRequest: exports.sendRequest,
+    on: exports.on,
+    off: exports.off,
+    once: exports.once,
+    emit: exports.emit,
+});
+exports.LambdaMicroserviceBrokerFactory = LambdaMicroserviceBrokerFactory;

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lambda-microservice.server';
+export * from './lambda-microservice.broker';

package/dist/server/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("./lambda-microservice.server"), exports);
+__exportStar(require("./lambda-microservice.broker"), exports);

package/dist/server/lambda-microservice.broker.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { ReplaySubject } from 'rxjs';
+import { OutgoingRequest, OutgoingResponse } from '../interfaces';
+export declare const RequestEvent: unique symbol;
+export declare const ResponseEvent: unique symbol;
+export type SupportedEvent = typeof RequestEvent | typeof ResponseEvent;
+export declare class LambdaMicroserviceBroker extends EventEmitter {
+    listen(callbackFn?: (...args: unknown[]) => void): void;
+    close(callbackFn?: (...args: unknown[]) => void): void;
+    sendRequest(outgoingRequest: OutgoingRequest): ReplaySubject<OutgoingResponse>;
+}
+export declare const LambdaMicroserviceBrokerFactory: () => LambdaMicroserviceBroker;

package/dist/server/lambda-microservice.broker.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaMicroserviceBrokerFactory = exports.LambdaMicroserviceBroker = exports.ResponseEvent = exports.RequestEvent = void 0;
+const events_1 = __importDefault(require("events"));
+const rxjs_1 = require("rxjs");
+const errors_1 = require("../errors");
+exports.RequestEvent = Symbol('Request');
+exports.ResponseEvent = Symbol('Response');
+class LambdaMicroserviceBroker extends events_1.default {
+    listen(callbackFn) {
+        callbackFn && callbackFn();
+    }
+    close(callbackFn) {
+        this.removeAllListeners(exports.ResponseEvent);
+        this.removeAllListeners(exports.RequestEvent);
+        callbackFn && callbackFn();
+    }
+    sendRequest(outgoingRequest) {
+        const responseStream$ = new rxjs_1.ReplaySubject();
+        const responseEventListener = (outgoingResponse) => {
+            if (outgoingResponse.id === outgoingRequest.id) {
+                responseStream$.next(outgoingResponse);
+                if (outgoingResponse.isDisposed) {
+                    responseStream$.complete();
+                    this.off(exports.ResponseEvent, responseEventListener);
+                }
+            }
+        };
+        if (this.listeners(exports.RequestEvent).length) {
+            this.on(exports.ResponseEvent, responseEventListener);
+            this.emit(exports.RequestEvent, outgoingRequest);
+        }
+        else {
+            responseStream$.error(new errors_1.NoConsumerError());
+        }
+        return responseStream$;
+    }
+}
+exports.LambdaMicroserviceBroker = LambdaMicroserviceBroker;
+const LambdaMicroserviceBrokerFactory = () => new LambdaMicroserviceBroker();
+exports.LambdaMicroserviceBrokerFactory = LambdaMicroserviceBrokerFactory;

package/dist/server/lambda-microservice.server.d.ts

@@ -0,0 +1,26 @@
+import 'reflect-metadata';
+import { Logger } from '@nestjs/common';
+import { CustomTransportStrategy, MessageHandler, MsPattern, Server } from '@nestjs/microservices';
+import { IncomingRequest } from '../interfaces';
+import { LambdaMicroserviceBroker } from './lambda-microservice.broker';
+export interface LambdaMicroserviceServerOptions {
+    broker: LambdaMicroserviceBroker;
+}
+export declare const CatchAllPattern = "*";
+export declare const PartialMatchExtraProp = "partialMatch";
+export declare const AwsLambdaTransportId: unique symbol;
+export declare class LambdaMicroserviceServer extends Server implements CustomTransportStrategy {
+    private readonly options;
+    readonly transportId: symbol;
+    protected readonly broker: LambdaMicroserviceBroker;
+    protected readonly handlerPatternsMap: Map<any, any>;
+    protected readonly logger: Logger;
+    constructor(options: LambdaMicroserviceServerOptions);
+    listen(callback: (error?: unknown) => void): Promise<void>;
+    close(): void;
+    addHandler(pattern: any, callback: MessageHandler, isEventHandler?: boolean, extras?: Record<string, any>): void;
+    protected handleMessage: (payload: IncomingRequest) => Promise<void | import("rxjs").Subscription>;
+    protected trySerializeIncomingRequest(incomingRequest: IncomingRequest): string;
+    getHandlerByPattern(messagePattern: MsPattern): MessageHandler | null;
+    performPatternMatch(handlerPatternPart: unknown, messagePatternPart: unknown, isPartialObjectMatchAllowed?: boolean): boolean;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaMicroserviceServer = exports.AwsLambdaTransportId = exports.PartialMatchExtraProp = exports.CatchAllPattern = void 0;
+require("reflect-metadata");
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const deserializers_1 = require("@nestjs/microservices/deserializers");
+const invalid_message_exception_1 = require("@nestjs/microservices/errors/invalid-message.exception");
+const serializers_1 = require("@nestjs/microservices/serializers");
+const ctx_host_1 = require("../ctx-host");
+const lambda_microservice_broker_1 = require("./lambda-microservice.broker");
+exports.CatchAllPattern = '*';
+exports.PartialMatchExtraProp = 'partialMatch';
+exports.AwsLambdaTransportId = Symbol('AWS_LAMBDA'); // Use it when registering the client
+class LambdaMicroserviceServer extends microservices_1.Server {
+    options;
+    transportId = exports.AwsLambdaTransportId;
+    broker;
+    handlerPatternsMap = new Map();
+    logger = new common_1.Logger(LambdaMicroserviceServer.name);
+    constructor(options) {
+        super();
+        this.options = options;
+        this.broker = this.options.broker;
+        this.serializer = new serializers_1.IdentitySerializer();
+        this.deserializer = new deserializers_1.IdentityDeserializer();
+    }
+    async listen(callback) {
+        try {
+            this.broker.listen(() => {
+                this.broker.on(lambda_microservice_broker_1.RequestEvent, this.handleMessage);
+                callback();
+            });
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+    close() {
+        this.broker.off(lambda_microservice_broker_1.RequestEvent, this.handleMessage);
+        this.broker.close();
+    }
+    addHandler(pattern, callback, isEventHandler = false, extras = {}) {
+        const normalizedPattern = this.normalizePattern(pattern);
+        // Guard against multiple handlers using same pattern
+        if (this.handlerPatternsMap.has(normalizedPattern)) {
+            throw new invalid_message_exception_1.InvalidMessageException();
+        }
+        this.handlerPatternsMap.set(normalizedPattern, pattern);
+        return super.addHandler(pattern, callback, isEventHandler, extras);
+    }
+    handleMessage = async (payload) => {
+        const { id, context } = payload;
+        const packet = await this.deserializer.deserialize(payload);
+        const lambdaContext = new ctx_host_1.LambdaContext([context]);
+        const publish = (data) => {
+            this.broker.emit(lambda_microservice_broker_1.ResponseEvent, this.serializer.serialize({ ...data, id }));
+        };
+        const handler = this.getHandlerByPattern(packet.pattern);
+        if (handler?.isEventHandler) {
+            this.logger.error('Event handlers are not supported by the lambda microservice. Switch to using message handlers to fix this error.', this.trySerializeIncomingRequest(payload));
+            return publish({
+                err: new Error('An illegal event handler qualified for processing the current message'),
+            });
+        }
+        if (!handler) {
+            this.logger.error('No handler qualified to process the message', this.trySerializeIncomingRequest(payload));
+            return publish({
+                err: new Error('No handler qualified to process the message'),
+            });
+        }
+        const response$ = this.transformToObservable(await handler(packet.data, lambdaContext));
+        return this.send(response$, publish);
+    };
+    trySerializeIncomingRequest(incomingRequest) {
+        try {
+            return JSON.stringify(incomingRequest);
+        }
+        catch (_error) {
+            return incomingRequest;
+        }
+    }
+    getHandlerByPattern(messagePattern) {
+        const route = this.getRouteFromPattern(messagePattern); // The getRouteFromPattern typings is wrongly accepting just strings
+        try {
+            // Exact match of the normalized pattern
+            if (this.messageHandlers.has(route)) {
+                return this.messageHandlers.get(route) ?? null;
+            }
+            // Denormalized match (e.g. if the original pattern is an object)
+            for (const [handlerPattern, handler] of this.messageHandlers.entries()) {
+                const originalHandlerPattern = this.handlerPatternsMap.get(handlerPattern) ?? route;
+                const isPartialMatch = Reflect.get(handler.extras ?? {}, exports.PartialMatchExtraProp) ?? false;
+                if (this.performPatternMatch(originalHandlerPattern, messagePattern, isPartialMatch)) {
+                    return handler;
+                }
+            }
+            // Catch all pattern
+            if (this.messageHandlers.has(exports.CatchAllPattern)) {
+                return this.messageHandlers.get(exports.CatchAllPattern) ?? null;
+            }
+        }
+        catch (_error) {
+            return null;
+        }
+        return null;
+    }
+    performPatternMatch(handlerPatternPart, messagePatternPart, isPartialObjectMatchAllowed = false) {
+        const isObject = (value) => typeof value === 'object' && Boolean(value);
+        const isPrimitive = (value) => ['string', 'number', 'boolean'].includes(typeof value);
+        // TODO If the handler provided @MessagePattern is a serialized MsObjectPattern, and its elements order does not match the incoming message pattern, it won't get qualified
+        // Potential solution detect, denormalize and match
+        if (isPrimitive(messagePatternPart)) {
+            return isPrimitive(handlerPatternPart) ? handlerPatternPart === messagePatternPart : false;
+        }
+        if (Array.isArray(messagePatternPart) && Array.isArray(handlerPatternPart)) {
+            const sortedMessagePattern = [...messagePatternPart].sort();
+            const sortedHandlerPattern = [...handlerPatternPart].sort();
+            if (isPartialObjectMatchAllowed) {
+                return sortedHandlerPattern.every((messageVal) => {
+                    if (isPrimitive(messageVal)) {
+                        return sortedMessagePattern.includes(messageVal);
+                    }
+                    return sortedHandlerPattern.some((handlerVal) => this.performPatternMatch(handlerVal, messageVal, isPartialObjectMatchAllowed));
+                });
+            }
+            return sortedMessagePattern.every((val, index) => {
+                return this.performPatternMatch(sortedHandlerPattern[index], val, isPartialObjectMatchAllowed);
+            });
+        }
+        if (isObject(messagePatternPart) && isObject(handlerPatternPart)) {
+            const handlerPatternKeys = Object.keys(handlerPatternPart);
+            const messagePatternKeys = Object.keys(messagePatternPart);
+            const keys = isPartialObjectMatchAllowed ? handlerPatternKeys : messagePatternKeys;
+            const hasSameShape = isPartialObjectMatchAllowed || handlerPatternKeys.length === messagePatternKeys.length;
+            return (hasSameShape &&
+                keys.every((key) => {
+                    return this.performPatternMatch(handlerPatternPart[key], messagePatternPart[key], isPartialObjectMatchAllowed);
+                }));
+        }
+        return false;
+    }
+}
+exports.LambdaMicroserviceServer = LambdaMicroserviceServer;

package/dist/server/mocks.d.ts

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

package/dist/server/mocks.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("./__mocks__"), exports);

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@klarna/nest-lambda-microservice",
+  "version": "0.1.0-beta.0",
+  "description": "NestJS based microservice for writing applications that run on AWS Lambda",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:klarna-incubator/nest-lambda-microservice.git"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "yarn build:clean && yarn build:ts",
+    "build:clean": "rm -rf dist",
+    "build:ts": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "lint": "eslint . --ext .ts --fix && prettier . --write --list-different --ignore-unknown && tsc -p tsconfig.json --noEmit",
+    "test": "yarn test:unit && yarn test:integration",
+    "test:unit": "jest --selectProjects unit --passWithNoTests --runInBand --detectOpenHandles --coverage",
+    "test:integration": "jest --selectProjects integration --passWithNoTests --runInBand --detectOpenHandles --coverage",
+    "prettier": "prettier 'src/**/*.ts'",
+    "prettier:fix": "prettier --write 'src/**/*.ts'"
+  },
+  "dependencies": {
+    "@nestjs/common": "10.3.0",
+    "@nestjs/core": "10.3.0",
+    "@nestjs/microservices": "10.3.0",
+    "reflect-metadata": "0.1.14",
+    "rxjs": "7.8.1",
+    "uuid": "9.0.1"
+  },
+  "devDependencies": {
+    "@jest/globals": "29.7.0",
+    "@nestjs/testing": "10.3.0",
+    "@tsconfig/node18": "18.2.2",
+    "@types/aws-lambda": "8.10.130",
+    "@types/node": "18.19.3",
+    "@types/uuid": "9.0.7",
+    "@typescript-eslint/eslint-plugin": "6.15.0",
+    "@typescript-eslint/parser": "6.15.0",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.0",
+    "eslint": "8.56.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.29.1",
+    "eslint-plugin-jest": "27.6.0",
+    "eslint-plugin-prettier": "5.1.1",
+    "jest": "29.7.0",
+    "prettier": "3.1.1",
+    "ts-jest": "29.1.1",
+    "typescript": "5.3.3"
+  },
+  "volta": {
+    "node": "18.19.0"
+  },
+  "license": "Apache-2.0"
+}