@hazeljs/serverless 0.2.0-beta.55 → 0.2.0-beta.57

package/dist/adapters.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapters.test.d.ts.map

package/dist/adapters.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.test.d.ts","sourceRoot":"","sources":["../src/adapters.test.ts"],"names":[],"mappings":""}

package/dist/adapters.test.js

@@ -0,0 +1,416 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    HazelApp: jest.fn(),
+    Container: { getInstance: jest.fn().mockReturnValue({}) },
+    Injectable: () => () => undefined,
+    HazelModule: () => () => undefined,
+    Type: null,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const core_1 = require("@hazeljs/core");
+const lambda_adapter_1 = require("./lambda.adapter");
+const cloud_function_adapter_1 = require("./cloud-function.adapter");
+const cold_start_optimizer_1 = require("./cold-start.optimizer");
+const serverless_decorator_1 = require("./serverless.decorator");
+class MockModule {
+}
+function makeEvent(overrides = {}) {
+    return {
+        httpMethod: 'GET',
+        path: '/test',
+        headers: {},
+        queryStringParameters: null,
+        body: null,
+        isBase64Encoded: false,
+        ...overrides,
+    };
+}
+function makeContext(overrides = {}) {
+    return {
+        awsRequestId: 'req-123',
+        invokedFunctionArn: 'arn:aws:lambda:us-east-1:000:function:test',
+        functionName: 'test-fn',
+        functionVersion: '$LATEST',
+        logGroupName: '/aws/lambda/test',
+        logStreamName: '2024/01/01/test',
+        memoryLimitInMB: '512',
+        getRemainingTimeInMillis: () => 30000,
+        done: jest.fn(),
+        fail: jest.fn(),
+        succeed: jest.fn(),
+        callbackWaitsForEmptyEventLoop: true,
+        ...overrides,
+    };
+}
+describe('LambdaAdapter', () => {
+    let mockMatch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockMatch = jest.fn().mockResolvedValue(null);
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: mockMatch }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    describe('createHandler() – cold start tracking', () => {
+        it('isCold() is true before first call', () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            expect(adapter.isCold()).toBe(true);
+        });
+        it('isCold() becomes false after first handler call', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(adapter.isCold()).toBe(false);
+        });
+        it('getApp() is undefined before handler is called', () => {
+            expect(new lambda_adapter_1.LambdaAdapter(MockModule).getApp()).toBeUndefined();
+        });
+        it('getApp() returns HazelApp after first call', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(adapter.getApp()).toBeDefined();
+        });
+    });
+    describe('createHandler() – routing', () => {
+        it('returns 404 when route is not found', async () => {
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            const result = await adapter.createHandler()(makeEvent({ path: '/missing' }), makeContext());
+            expect(result.statusCode).toBe(404);
+            expect(JSON.parse(result.body)).toMatchObject({ message: 'Route not found' });
+        });
+        it('calls matched route handler and returns json response', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.json({ ok: true }),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(200);
+            expect(JSON.parse(result.body)).toEqual({ ok: true });
+        });
+        it('uses returned value from handler when res methods are not called', async () => {
+            mockMatch.mockResolvedValue({ handler: async () => ({ direct: 'return' }) });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(JSON.parse(result.body)).toEqual({ direct: 'return' });
+        });
+        it('respects res.status() code', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.status(201).json({ created: true }),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST' }), makeContext());
+            expect(result.statusCode).toBe(201);
+        });
+        it('returns string body from res.send()', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => res.send('plain text'),
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.body).toBe('plain text');
+        });
+        it('supports res.setHeader()', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => {
+                    res.setHeader('X-Custom', 'value');
+                    res.json({});
+                },
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.headers?.['X-Custom']).toBe('value');
+        });
+        it('returns error statusCode from thrown error with statusCode property', async () => {
+            const err = Object.assign(new Error('Forbidden'), { statusCode: 403 });
+            mockMatch.mockRejectedValue(err);
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(403);
+        });
+        it('returns 500 when route handler throws without statusCode', async () => {
+            mockMatch.mockRejectedValue(new Error('Unexpected'));
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(500);
+        });
+    });
+    describe('createHandler() – request conversion', () => {
+        it('parses JSON body', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: '{"key":"val"}' }), makeContext());
+            expect(capturedBody).toEqual({ key: 'val' });
+        });
+        it('parses base64-encoded JSON body', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            const b64 = Buffer.from(JSON.stringify({ encoded: true })).toString('base64');
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: b64, isBase64Encoded: true }), makeContext());
+            expect(capturedBody).toEqual({ encoded: true });
+        });
+        it('returns raw string body when JSON parse fails', async () => {
+            let capturedBody;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedBody = req.body;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ httpMethod: 'POST', body: 'not-valid-json' }), makeContext());
+            expect(capturedBody).toBe('not-valid-json');
+        });
+        it('passes query string parameters to handler', async () => {
+            let capturedQuery;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedQuery = req.query;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ queryStringParameters: { page: '2', size: '10' } }), makeContext());
+            expect(capturedQuery).toEqual({ page: '2', size: '10' });
+        });
+        it('passes pathParameters to handler', async () => {
+            let capturedParams;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedParams = req.params;
+                    res.json({});
+                },
+            });
+            await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent({ pathParameters: { id: '42' } }), makeContext());
+            expect(capturedParams).toEqual({ id: '42' });
+        });
+    });
+    describe('createHandler() – initialization errors', () => {
+        it('returns 500 when HazelApp constructor throws', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('Module init failed');
+            });
+            const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(500);
+            expect(JSON.parse(result.body).message).toBe('Module init failed');
+        });
+    });
+    describe('createHandler() – app reuse', () => {
+        it('creates HazelApp only once across multiple calls', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule);
+            const handler = adapter.createHandler();
+            await handler(makeEvent(), makeContext());
+            await handler(makeEvent(), makeContext());
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('cold start optimization', () => {
+        it('calls warmUp when module has @Serverless coldStartOptimization:true', async () => {
+            let OptimizedModule = class OptimizedModule {
+            };
+            OptimizedModule = __decorate([
+                (0, serverless_decorator_1.Serverless)({ coldStartOptimization: true })
+            ], OptimizedModule);
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(OptimizedModule);
+            await adapter.createHandler()(makeEvent(), makeContext());
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+describe('createLambdaHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn().mockResolvedValue(null) }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable handler that produces a ServerlessResponse', async () => {
+        const handler = (0, lambda_adapter_1.createLambdaHandler)(MockModule);
+        const result = await handler(makeEvent(), makeContext());
+        expect(result).toHaveProperty('statusCode');
+        expect(result).toHaveProperty('body');
+    });
+});
+// ─── CloudFunctionAdapter ────────────────────────────────────────────────────
+function makeCloudReq(overrides = {}) {
+    return {
+        method: 'GET',
+        url: '/test',
+        path: '/test',
+        headers: { 'content-type': 'application/json' },
+        query: {},
+        ...overrides,
+    };
+}
+function makeCloudRes() {
+    const captures = {
+        headers: {},
+    };
+    const res = {
+        _captures: captures,
+        status: jest.fn().mockReturnThis(),
+        set: jest.fn().mockReturnThis(),
+        send: jest.fn().mockImplementation((b) => {
+            captures.body = b;
+        }),
+        json: jest.fn().mockImplementation((b) => {
+            captures.body = b;
+        }),
+        end: jest.fn(),
+    };
+    return res;
+}
+describe('CloudFunctionAdapter', () => {
+    let mockMatch;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockMatch = jest.fn().mockResolvedValue(null);
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: mockMatch }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    describe('createHttpHandler()', () => {
+        it('calls res.status(404) when route not found', async () => {
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.status).toHaveBeenCalledWith(404);
+            expect(res.send).toHaveBeenCalled();
+        });
+        it('calls matched route and sends response', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, synRes) => synRes.json({ ok: true }),
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.send).toHaveBeenCalled();
+        });
+        it('calls res.status(500).json() on handler init error', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('crash');
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.status).toHaveBeenCalledWith(500);
+            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ error: 'Internal Server Error' }));
+        });
+        it('normalizes string[] headers to first value', async () => {
+            let capturedHeaders;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedHeaders = req.headers;
+                    res.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq({ headers: { 'x-multi': ['alpha', 'beta'] } }), res);
+            expect(capturedHeaders?.['x-multi']).toBe('alpha');
+        });
+        it('normalizes string[] query params to first value', async () => {
+            let capturedQuery;
+            mockMatch.mockResolvedValue({
+                handler: async (req, res) => {
+                    capturedQuery = req.query;
+                    res.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq({ query: { tag: ['first', 'second'] } }), res);
+            expect(capturedQuery?.tag).toBe('first');
+        });
+        it('sets headers on response from internal ServerlessResponse headers', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, synRes) => {
+                    synRes.setHeader('X-Trace', 'abc');
+                    synRes.json({});
+                },
+            });
+            const res = makeCloudRes();
+            await new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createHttpHandler()(makeCloudReq(), res);
+            expect(res.set).toHaveBeenCalledWith('X-Trace', 'abc');
+        });
+        it('isCold() becomes false after first call', async () => {
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            expect(adapter.isCold()).toBe(true);
+            const res = makeCloudRes();
+            await adapter.createHttpHandler()(makeCloudReq(), res);
+            expect(adapter.isCold()).toBe(false);
+        });
+        it('getApp() returns undefined before first call', () => {
+            expect(new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).getApp()).toBeUndefined();
+        });
+        it('creates HazelApp only once across multiple calls', async () => {
+            mockMatch.mockResolvedValue({
+                handler: async (_r, res) => res.json({}),
+            });
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            const handler = adapter.createHttpHandler();
+            const res1 = makeCloudRes();
+            const res2 = makeCloudRes();
+            await handler(makeCloudReq(), res1);
+            await handler(makeCloudReq(), res2);
+            expect(core_1.HazelApp).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('createEventHandler()', () => {
+        it('resolves without error for a valid event', async () => {
+            const handler = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createEventHandler();
+            await expect(handler({ data: 'payload' }, { eventType: 'pubsub', resource: 'projects/test' })).resolves.toBeUndefined();
+        });
+        it('rethrows errors from initialization', async () => {
+            core_1.HazelApp.mockImplementationOnce(() => {
+                throw new Error('init failed');
+            });
+            const handler = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule).createEventHandler();
+            await expect(handler({}, {})).rejects.toThrow('init failed');
+        });
+        it('isCold() becomes false after first event call', async () => {
+            const adapter = new cloud_function_adapter_1.CloudFunctionAdapter(MockModule);
+            await adapter.createEventHandler()({}, {});
+            expect(adapter.isCold()).toBe(false);
+        });
+    });
+});
+describe('createCloudFunctionHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn().mockResolvedValue(null) }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable HTTP handler', async () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionHandler)(MockModule);
+        const res = makeCloudRes();
+        await handler(makeCloudReq(), res);
+        expect(res.send).toHaveBeenCalled();
+    });
+});
+describe('createCloudFunctionEventHandler()', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        core_1.HazelApp.mockImplementation(() => ({
+            getRouter: jest.fn().mockReturnValue({ match: jest.fn() }),
+        }));
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    it('returns a callable event handler', async () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionEventHandler)(MockModule);
+        await expect(handler({ data: 'test' }, {})).resolves.toBeUndefined();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/serverless",
-  "version": "0.2.0-beta.55",
+  "version": "0.2.0-beta.57",
   "description": "Serverless adapters (AWS Lambda, Google Cloud Functions) for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,5 +48,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
+  "gitHead": "98c84683e8f487c660e344c2beda3a8dcaaff07f"
 }