@hazeljs/serverless 0.2.0-beta.1

package/dist/lambda.adapter.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaAdapter = void 0;
+exports.createLambdaHandler = createLambdaHandler;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const serverless_decorator_1 = require("./serverless.decorator");
+const cold_start_optimizer_1 = require("./cold-start.optimizer");
+/**
+ * Lambda adapter for HazelJS
+ */
+class LambdaAdapter {
+    constructor(moduleClass) {
+        this.moduleClass = moduleClass;
+        this.isColdStart = true;
+        this.optimizer = cold_start_optimizer_1.ColdStartOptimizer.getInstance();
+    }
+    /**
+     * Initialize the HazelJS application
+     */
+    async initialize() {
+        if (this.app) {
+            return;
+        }
+        const startTime = Date.now();
+        core_2.default.info('Initializing HazelJS application for Lambda...');
+        // Check if cold start optimization is enabled
+        const metadata = (0, serverless_decorator_1.getServerlessMetadata)(this.moduleClass);
+        if (metadata?.coldStartOptimization) {
+            await this.optimizer.warmUp();
+        }
+        // Create HazelJS application
+        this.app = new core_1.HazelApp(this.moduleClass);
+        const duration = Date.now() - startTime;
+        core_2.default.info(`Lambda initialization completed in ${duration}ms`);
+    }
+    /**
+     * Create Lambda handler
+     */
+    createHandler() {
+        return async (event, context) => {
+            try {
+                // Log cold start
+                if (this.isColdStart) {
+                    core_2.default.info('Lambda cold start detected');
+                    this.isColdStart = false;
+                }
+                // Initialize application
+                await this.initialize();
+                // Convert Lambda event to HTTP request
+                const request = this.convertLambdaEventToRequest(event, context);
+                // Process request through HazelJS
+                const response = await this.processRequest(request);
+                return response;
+            }
+            catch (error) {
+                core_2.default.error('Lambda handler error:', error);
+                return {
+                    statusCode: 500,
+                    body: JSON.stringify({
+                        error: 'Internal Server Error',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                    }),
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                };
+            }
+        };
+    }
+    /**
+     * Convert Lambda event to HTTP request format
+     */
+    convertLambdaEventToRequest(event, context) {
+        return {
+            method: event.httpMethod || 'GET',
+            url: event.path || '/',
+            headers: event.headers || {},
+            query: event.queryStringParameters || {},
+            params: event.pathParameters || {},
+            body: event.body ? this.parseBody(event.body, event.isBase64Encoded) : undefined,
+            context: {
+                requestId: context.awsRequestId,
+                functionName: context.functionName,
+                remainingTime: context.getRemainingTimeInMillis(),
+            },
+        };
+    }
+    /**
+     * Parse request body
+     */
+    parseBody(body, isBase64Encoded) {
+        try {
+            if (isBase64Encoded) {
+                const decoded = Buffer.from(body, 'base64').toString('utf-8');
+                return JSON.parse(decoded);
+            }
+            return JSON.parse(body);
+        }
+        catch {
+            return body;
+        }
+    }
+    /**
+     * Process request through HazelJS router
+     */
+    async processRequest(request) {
+        if (!this.app) {
+            return {
+                statusCode: 500,
+                body: JSON.stringify({ message: 'Application not initialized' }),
+                headers: { 'Content-Type': 'application/json' },
+            };
+        }
+        const router = this.app.getRouter();
+        // Build request context for the router
+        const context = {
+            method: request.method,
+            url: request.url,
+            headers: request.headers,
+            query: request.query,
+            params: request.params,
+            body: request.body,
+            requestId: request.context.requestId,
+        };
+        try {
+            const route = await router.match(request.method, request.url, context);
+            if (!route) {
+                return {
+                    statusCode: 404,
+                    body: JSON.stringify({ statusCode: 404, message: 'Route not found' }),
+                    headers: { 'Content-Type': 'application/json' },
+                };
+            }
+            // Create a synthetic request/response to capture the handler output
+            const syntheticReq = {
+                method: request.method,
+                url: request.url,
+                headers: request.headers,
+                query: request.query,
+                params: context.params || {},
+                body: request.body,
+            };
+            let responseBody;
+            let responseStatus = 200;
+            const responseHeaders = { 'Content-Type': 'application/json' };
+            const syntheticRes = {
+                statusCode: 200,
+                status(code) { responseStatus = code; return syntheticRes; },
+                json(data) { responseBody = data; responseStatus = responseStatus || 200; },
+                send(data) { responseBody = data; },
+                setHeader(key, value) { responseHeaders[key] = value; },
+                getHeader(key) { return responseHeaders[key]; },
+            };
+            const result = await route.handler(syntheticReq, syntheticRes);
+            // If handler returned a value directly, use it
+            if (result !== undefined && responseBody === undefined) {
+                responseBody = result;
+            }
+            return {
+                statusCode: responseStatus,
+                body: typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody),
+                headers: responseHeaders,
+            };
+        }
+        catch (error) {
+            const statusCode = error.statusCode || 500;
+            const message = error instanceof Error ? error.message : 'Internal Server Error';
+            return {
+                statusCode,
+                body: JSON.stringify({ statusCode, message }),
+                headers: { 'Content-Type': 'application/json' },
+            };
+        }
+    }
+    /**
+     * Get application instance
+     */
+    getApp() {
+        return this.app;
+    }
+    /**
+     * Check if this is a cold start
+     */
+    isCold() {
+        return this.isColdStart;
+    }
+}
+exports.LambdaAdapter = LambdaAdapter;
+/**
+ * Create a Lambda handler for a HazelJS module
+ *
+ * @example
+ * ```typescript
+ * // handler.ts
+ * import { createLambdaHandler } from '@hazeljs/core';
+ * import { AppModule } from './app.module';
+ *
+ * export const handler = createLambdaHandler(AppModule);
+ * ```
+ */
+function createLambdaHandler(moduleClass) {
+    const adapter = new LambdaAdapter(moduleClass);
+    return adapter.createHandler();
+}

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/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@hazeljs/serverless",
+  "version": "0.2.0-beta.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"
+  },
+  "dependencies": {
+    "@hazeljs/core": "file:../core"
+  },
+  "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 <marslan@hazeljs.com>",
+  "license": "MIT"
+}