@hazeljs/serverless 0.2.0-alpha.1

package/dist/serverless.decorator.d.ts

@@ -0,0 +1,166 @@
+import 'reflect-metadata';
+/**
+ * Serverless configuration options
+ */
+export interface ServerlessOptions {
+    /**
+     * Memory allocation in MB
+     * @default 512
+     */
+    memory?: number;
+    /**
+     * Timeout in seconds
+     * @default 30
+     */
+    timeout?: number;
+    /**
+     * Enable cold start optimization
+     * @default true
+     */
+    coldStartOptimization?: boolean;
+    /**
+     * Environment variables
+     */
+    environment?: Record<string, string>;
+    /**
+     * Runtime platform
+     */
+    runtime?: 'aws-lambda' | 'gcp-functions' | 'azure-functions' | 'cloudflare-workers';
+    /**
+     * Enable automatic function splitting
+     * @default false
+     */
+    autoSplit?: boolean;
+    /**
+     * Reserved concurrent executions (AWS Lambda)
+     */
+    reservedConcurrency?: number;
+    /**
+     * Provisioned concurrency (AWS Lambda)
+     */
+    provisionedConcurrency?: number;
+}
+/**
+ * Decorator to mark a controller as serverless-optimized
+ *
+ * @example
+ * ```typescript
+ * @Serverless({
+ *   memory: 512,
+ *   timeout: 30,
+ *   coldStartOptimization: true
+ * })
+ * @Controller('/lambda')
+ * export class LambdaController {
+ *   @Get()
+ *   async handler() {
+ *     return { message: 'Hello from serverless!' };
+ *   }
+ * }
+ * ```
+ */
+export declare function Serverless(options?: ServerlessOptions): ClassDecorator;
+/**
+ * Get serverless metadata from a class
+ */
+export declare function getServerlessMetadata(target: object | (new (...args: unknown[]) => object)): ServerlessOptions | undefined;
+/**
+ * Check if a class is marked as serverless
+ */
+export declare function isServerless(target: object | (new (...args: unknown[]) => object)): boolean;
+/**
+ * Serverless function handler type
+ */
+export type ServerlessHandler<TEvent = unknown, TResult = unknown> = (event: TEvent, context: ServerlessContext) => Promise<TResult> | TResult;
+/**
+ * Serverless execution context
+ */
+export interface ServerlessContext {
+    /**
+     * Request ID
+     */
+    requestId: string;
+    /**
+     * Function name
+     */
+    functionName: string;
+    /**
+     * Function version
+     */
+    functionVersion: string;
+    /**
+     * Memory limit in MB
+     */
+    memoryLimitInMB: number;
+    /**
+     * Remaining time in milliseconds
+     */
+    getRemainingTimeInMillis(): number;
+    /**
+     * Log stream name
+     */
+    logStreamName?: string;
+    /**
+     * Log group name
+     */
+    logGroupName?: string;
+    /**
+     * Additional platform-specific context
+     */
+    [key: string]: unknown;
+}
+/**
+ * Serverless event types
+ */
+export interface ServerlessEvent {
+    /**
+     * HTTP method
+     */
+    httpMethod?: string;
+    /**
+     * Request path
+     */
+    path?: string;
+    /**
+     * Query parameters
+     */
+    queryStringParameters?: Record<string, string>;
+    /**
+     * Headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request body
+     */
+    body?: string;
+    /**
+     * Is base64 encoded
+     */
+    isBase64Encoded?: boolean;
+    /**
+     * Additional platform-specific event data
+     */
+    [key: string]: unknown;
+}
+/**
+ * Serverless response
+ */
+export interface ServerlessResponse {
+    /**
+     * Status code
+     */
+    statusCode: number;
+    /**
+     * Response headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Response body
+     */
+    body: string;
+    /**
+     * Is base64 encoded
+     */
+    isBase64Encoded?: boolean;
+}
+//# sourceMappingURL=serverless.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serverless.decorator.d.ts","sourceRoot":"","sources":["../src/serverless.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAG1B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,GAAG,eAAe,GAAG,iBAAiB,GAAG,oBAAoB,CAAC;IAEpF;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAc1E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,GACpD,iBAAiB,GAAG,SAAS,CAE/B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,GAAG,OAAO,CAE3F;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,CACnE,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,iBAAiB,KACvB,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEhC;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,wBAAwB,IAAI,MAAM,CAAC;IAEnC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE/C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B"}

package/dist/serverless.decorator.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Serverless = Serverless;
+exports.getServerlessMetadata = getServerlessMetadata;
+exports.isServerless = isServerless;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const SERVERLESS_METADATA_KEY = 'hazel:serverless';
+/**
+ * Decorator to mark a controller as serverless-optimized
+ *
+ * @example
+ * ```typescript
+ * @Serverless({
+ *   memory: 512,
+ *   timeout: 30,
+ *   coldStartOptimization: true
+ * })
+ * @Controller('/lambda')
+ * export class LambdaController {
+ *   @Get()
+ *   async handler() {
+ *     return { message: 'Hello from serverless!' };
+ *   }
+ * }
+ * ```
+ */
+function Serverless(options = {}) {
+    return (target) => {
+        const defaults = {
+            memory: 512,
+            timeout: 30,
+            coldStartOptimization: true,
+            autoSplit: false,
+            ...options,
+        };
+        const targetName = typeof target === 'function' ? target.name : 'unknown';
+        core_1.default.debug(`Marking ${targetName} as serverless with options:`, defaults);
+        Reflect.defineMetadata(SERVERLESS_METADATA_KEY, defaults, target);
+    };
+}
+/**
+ * Get serverless metadata from a class
+ */
+function getServerlessMetadata(target) {
+    return Reflect.getMetadata(SERVERLESS_METADATA_KEY, target);
+}
+/**
+ * Check if a class is marked as serverless
+ */
+function isServerless(target) {
+    return Reflect.hasMetadata(SERVERLESS_METADATA_KEY, target);
+}

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

@@ -0,0 +1,52 @@
+{
+  "name": "@hazeljs/serverless",
+  "version": "0.2.0-alpha.1",
+  "description": "Serverless adapters (AWS Lambda, Google Cloud Functions) for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.145",
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/serverless"
+  },
+  "keywords": [
+    "hazeljs",
+    "serverless",
+    "lambda",
+    "cloud-functions",
+    "aws"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}