@hazeljs/serverless 0.2.0-beta.54 → 0.2.0-beta.56

package/README.md

@@ -498,4 +498,4 @@ Apache 2.0 © [HazelJS](https://hazeljs.com)
 - [Google Cloud Functions Docs](https://cloud.google.com/functions/docs)
 - [GitHub](https://github.com/hazel-js/hazeljs)
 - [Issues](https://github.com/hazel-js/hazeljs/issues)
-- [Discord](https://discord.gg/hazeljs)
+- [Discord](https://discord.com/channels/1448263814238965833/1448263814859456575)

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/dist/serverless.test.d.ts

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

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

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

package/dist/serverless.test.js

@@ -0,0 +1,246 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const serverless_decorator_1 = require("./serverless.decorator");
+const cold_start_optimizer_1 = require("./cold-start.optimizer");
+const lambda_adapter_1 = require("./lambda.adapter");
+const cloud_function_adapter_1 = require("./cloud-function.adapter");
+const core_1 = require("@hazeljs/core");
+describe('Serverless Decorator', () => {
+    it('should mark class as serverless', () => {
+        let TestController = class TestController {
+        };
+        TestController = __decorate([
+            (0, serverless_decorator_1.Serverless)()
+        ], TestController);
+        expect((0, serverless_decorator_1.isServerless)(TestController)).toBe(true);
+    });
+    it('should store serverless metadata', () => {
+        const options = {
+            memory: 1024,
+            timeout: 60,
+            coldStartOptimization: true,
+        };
+        let TestController = class TestController {
+        };
+        TestController = __decorate([
+            (0, serverless_decorator_1.Serverless)(options)
+        ], TestController);
+        const metadata = (0, serverless_decorator_1.getServerlessMetadata)(TestController);
+        expect(metadata).toBeDefined();
+        expect(metadata?.memory).toBe(1024);
+        expect(metadata?.timeout).toBe(60);
+        expect(metadata?.coldStartOptimization).toBe(true);
+    });
+    it('should use default options', () => {
+        let TestController = class TestController {
+        };
+        TestController = __decorate([
+            (0, serverless_decorator_1.Serverless)()
+        ], TestController);
+        const metadata = (0, serverless_decorator_1.getServerlessMetadata)(TestController);
+        expect(metadata?.memory).toBe(512);
+        expect(metadata?.timeout).toBe(30);
+        expect(metadata?.coldStartOptimization).toBe(true);
+        expect(metadata?.autoSplit).toBe(false);
+    });
+    it('should return undefined for non-serverless class', () => {
+        class TestController {
+        }
+        expect((0, serverless_decorator_1.isServerless)(TestController)).toBe(false);
+        expect((0, serverless_decorator_1.getServerlessMetadata)(TestController)).toBeUndefined();
+    });
+});
+describe('ColdStartOptimizer', () => {
+    let optimizer;
+    beforeEach(() => {
+        optimizer = cold_start_optimizer_1.ColdStartOptimizer.getInstance();
+        optimizer.reset();
+    });
+    describe('warmUp', () => {
+        it('should warm up the application', async () => {
+            expect(optimizer.isWarm()).toBe(false);
+            await optimizer.warmUp();
+            expect(optimizer.isWarm()).toBe(true);
+            expect(optimizer.getWarmupTimestamp()).toBeDefined();
+        });
+        it('should not warm up twice', async () => {
+            await optimizer.warmUp();
+            const firstTimestamp = optimizer.getWarmupTimestamp();
+            await optimizer.warmUp();
+            const secondTimestamp = optimizer.getWarmupTimestamp();
+            expect(firstTimestamp).toBe(secondTimestamp);
+        });
+        it('should preload critical modules', async () => {
+            await optimizer.warmUp();
+            const preloaded = optimizer.getPreloadedModules();
+            expect(preloaded.length).toBeGreaterThan(0);
+            expect(preloaded).toContain('http');
+            expect(preloaded).toContain('crypto');
+        });
+    });
+    describe('isWarm', () => {
+        it('should return false initially', () => {
+            expect(optimizer.isWarm()).toBe(false);
+        });
+        it('should return true after warmup', async () => {
+            await optimizer.warmUp();
+            expect(optimizer.isWarm()).toBe(true);
+        });
+    });
+    describe('getWarmupDuration', () => {
+        it('should return undefined before warmup', () => {
+            expect(optimizer.getWarmupDuration()).toBeUndefined();
+        });
+        it('should return duration after warmup', async () => {
+            await optimizer.warmUp();
+            const duration = optimizer.getWarmupDuration();
+            expect(duration).toBeDefined();
+            expect(duration).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('reset', () => {
+        it('should reset warmup state', async () => {
+            await optimizer.warmUp();
+            expect(optimizer.isWarm()).toBe(true);
+            optimizer.reset();
+            expect(optimizer.isWarm()).toBe(false);
+            expect(optimizer.getWarmupTimestamp()).toBeUndefined();
+            expect(optimizer.getPreloadedModules()).toHaveLength(0);
+        });
+    });
+});
+describe('OptimizeColdStart Decorator', () => {
+    let optimizer;
+    beforeEach(() => {
+        optimizer = cold_start_optimizer_1.ColdStartOptimizer.getInstance();
+        optimizer.reset();
+    });
+    it('should warm up before method execution', async () => {
+        class TestClass {
+            async testMethod() {
+                return 'result';
+            }
+        }
+        __decorate([
+            (0, cold_start_optimizer_1.OptimizeColdStart)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], TestClass.prototype, "testMethod", null);
+        const instance = new TestClass();
+        expect(optimizer.isWarm()).toBe(false);
+        const result = await instance.testMethod();
+        expect(result).toBe('result');
+        expect(optimizer.isWarm()).toBe(true);
+    });
+});
+describe('KeepAliveHelper', () => {
+    let helper;
+    beforeEach(() => {
+        helper = new cold_start_optimizer_1.KeepAliveHelper();
+    });
+    afterEach(() => {
+        helper.stop();
+    });
+    it('should start keep-alive', () => {
+        expect(() => {
+            helper.start('http://example.com', 1000);
+        }).not.toThrow();
+    });
+    it('should stop keep-alive', () => {
+        helper.start('http://example.com', 1000);
+        expect(() => {
+            helper.stop();
+        }).not.toThrow();
+    });
+});
+describe('LambdaAdapter', () => {
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, core_1.HazelModule)({
+            controllers: [],
+        })
+    ], TestModule);
+    let adapter;
+    beforeEach(() => {
+        adapter = new lambda_adapter_1.LambdaAdapter(TestModule);
+    });
+    it('should create Lambda adapter', () => {
+        expect(adapter).toBeDefined();
+    });
+    it('should create handler function', () => {
+        const handler = adapter.createHandler();
+        expect(handler).toBeDefined();
+        expect(typeof handler).toBe('function');
+    });
+    it('should be cold on first check', () => {
+        expect(adapter.isCold()).toBe(true);
+    });
+});
+describe('createLambdaHandler', () => {
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, core_1.HazelModule)({
+            controllers: [],
+        })
+    ], TestModule);
+    it('should create Lambda handler', () => {
+        const handler = (0, lambda_adapter_1.createLambdaHandler)(TestModule);
+        expect(handler).toBeDefined();
+        expect(typeof handler).toBe('function');
+    });
+});
+describe('CloudFunctionAdapter', () => {
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, core_1.HazelModule)({
+            controllers: [],
+        })
+    ], TestModule);
+    let adapter;
+    beforeEach(() => {
+        adapter = new cloud_function_adapter_1.CloudFunctionAdapter(TestModule);
+    });
+    it('should create Cloud Function adapter', () => {
+        expect(adapter).toBeDefined();
+    });
+    it('should create HTTP handler', () => {
+        const handler = adapter.createHttpHandler();
+        expect(handler).toBeDefined();
+        expect(typeof handler).toBe('function');
+    });
+    it('should create event handler', () => {
+        const handler = adapter.createEventHandler();
+        expect(handler).toBeDefined();
+        expect(typeof handler).toBe('function');
+    });
+    it('should be cold on first check', () => {
+        expect(adapter.isCold()).toBe(true);
+    });
+});
+describe('createCloudFunctionHandler', () => {
+    let TestModule = class TestModule {
+    };
+    TestModule = __decorate([
+        (0, core_1.HazelModule)({
+            controllers: [],
+        })
+    ], TestModule);
+    it('should create Cloud Function HTTP handler', () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionHandler)(TestModule);
+        expect(handler).toBeDefined();
+        expect(typeof handler).toBe('function');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/serverless",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.56",
   "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": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "c2737e90974458a8438eee623726f0a453b66b8b"
 }