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

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/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.55",
   "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": "f2e54f346eea552595a44607999454a9e388cb9e"
 }