@hazeljs/serverless 0.2.0-alpha.1

package/dist/integration.test.js

@@ -0,0 +1,191 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Integration tests: real HazelJS app through Lambda and Cloud Function adapters.
+ * No mocks of @hazeljs/core — uses real HazelApp, router, and controllers.
+ */
+require("reflect-metadata");
+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");
+// ─── Minimal app for integration ───────────────────────────────────────────
+let IntegrationController = class IntegrationController {
+    ping() {
+        return { ok: true, message: 'pong' };
+    }
+    getById(id) {
+        return { id };
+    }
+    echo(body) {
+        return { echoed: body };
+    }
+};
+__decorate([
+    (0, core_1.Get)('/ping'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], IntegrationController.prototype, "ping", null);
+__decorate([
+    (0, core_1.Get)('/params/:id'),
+    __param(0, (0, core_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], IntegrationController.prototype, "getById", null);
+__decorate([
+    (0, core_1.Post)('/echo'),
+    __param(0, (0, core_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], IntegrationController.prototype, "echo", null);
+IntegrationController = __decorate([
+    (0, core_1.Controller)('/api')
+], IntegrationController);
+let IntegrationTestModule = class IntegrationTestModule {
+};
+IntegrationTestModule = __decorate([
+    (0, core_1.HazelModule)({
+        controllers: [IntegrationController],
+    })
+], IntegrationTestModule);
+// ─── Lambda helpers ──────────────────────────────────────────────────────────
+function makeLambdaEvent(overrides = {}) {
+    return {
+        httpMethod: 'GET',
+        path: '/api/ping',
+        headers: { 'content-type': 'application/json' },
+        queryStringParameters: null,
+        body: null,
+        isBase64Encoded: false,
+        ...overrides,
+    };
+}
+function makeLambdaContext(overrides = {}) {
+    return {
+        awsRequestId: 'int-test-req-1',
+        invokedFunctionArn: 'arn:aws:lambda:us-east-1:000:function:integration-test',
+        functionName: 'integration-test',
+        functionVersion: '$LATEST',
+        getRemainingTimeInMillis: () => 30000,
+        callbackWaitsForEmptyEventLoop: true,
+        ...overrides,
+    };
+}
+// ─── Cloud Function helpers ──────────────────────────────────────────────────
+function makeCloudReq(overrides = {}) {
+    return {
+        method: 'GET',
+        url: '/api/ping',
+        path: '/api/ping',
+        headers: { 'content-type': 'application/json' },
+        query: {},
+        ...overrides,
+    };
+}
+function makeCloudRes() {
+    const state = {
+        _status: 200,
+        _body: undefined,
+        _headers: {},
+    };
+    return Object.assign(state, {
+        status(code) {
+            state._status = code;
+            return this;
+        },
+        set(field, value) {
+            state._headers[field] = value;
+            return this;
+        },
+        send(body) {
+            state._body = body;
+        },
+        json(body) {
+            state._body = body;
+        },
+        end() { },
+    });
+}
+// ─── Integration tests ───────────────────────────────────────────────────────
+describe('integration (real HazelApp)', () => {
+    beforeEach(() => {
+        cold_start_optimizer_1.ColdStartOptimizer.getInstance().reset();
+    });
+    describe('createLambdaHandler', () => {
+        const handler = (0, lambda_adapter_1.createLambdaHandler)(IntegrationTestModule);
+        it('GET /api/ping returns 200 and pong', async () => {
+            const result = await handler(makeLambdaEvent({ httpMethod: 'GET', path: '/api/ping' }), makeLambdaContext());
+            expect(result.statusCode).toBe(200);
+            const data = JSON.parse(result.body);
+            expect(data).toEqual({ ok: true, message: 'pong' });
+        });
+        it('GET /api/params/123 returns 200 and id', async () => {
+            const result = await handler(makeLambdaEvent({
+                httpMethod: 'GET',
+                path: '/api/params/123',
+                pathParameters: { id: '123' },
+            }), makeLambdaContext());
+            expect(result.statusCode).toBe(200);
+            const data = JSON.parse(result.body);
+            expect(data).toEqual({ id: '123' });
+        });
+        it('POST /api/echo returns 200 and echoed body', async () => {
+            const result = await handler(makeLambdaEvent({
+                httpMethod: 'POST',
+                path: '/api/echo',
+                body: JSON.stringify({ x: 1, text: 'hello' }),
+            }), makeLambdaContext());
+            expect(result.statusCode).toBe(200);
+            const data = JSON.parse(result.body);
+            expect(data).toEqual({ echoed: { x: 1, text: 'hello' } });
+        });
+        it('GET /api/missing returns 404', async () => {
+            const result = await handler(makeLambdaEvent({ httpMethod: 'GET', path: '/api/missing' }), makeLambdaContext());
+            expect(result.statusCode).toBe(404);
+            const data = JSON.parse(result.body);
+            expect(data.message).toBe('Route not found');
+        });
+    });
+    describe('createCloudFunctionHandler', () => {
+        const handler = (0, cloud_function_adapter_1.createCloudFunctionHandler)(IntegrationTestModule);
+        it('GET /api/ping returns 200 and pong', async () => {
+            const res = makeCloudRes();
+            await handler(makeCloudReq({ method: 'GET', url: '/api/ping', path: '/api/ping' }), res);
+            expect(res._status).toBe(200);
+            const body = typeof res._body === 'string' ? JSON.parse(res._body) : res._body;
+            expect(body).toEqual({ ok: true, message: 'pong' });
+        });
+        it('POST /api/echo returns 200 and echoed body', async () => {
+            const res = makeCloudRes();
+            await handler(makeCloudReq({
+                method: 'POST',
+                url: '/api/echo',
+                path: '/api/echo',
+                body: { x: 2, text: 'world' },
+            }), res);
+            expect(res._status).toBe(200);
+            const body = typeof res._body === 'string' ? JSON.parse(res._body) : res._body;
+            expect(body).toEqual({ echoed: { x: 2, text: 'world' } });
+        });
+        it('GET /api/missing returns 404', async () => {
+            const res = makeCloudRes();
+            await handler(makeCloudReq({ method: 'GET', url: '/api/missing', path: '/api/missing' }), res);
+            expect(res._status).toBe(404);
+        });
+    });
+});

package/dist/lambda.adapter.d.ts

@@ -0,0 +1,102 @@
+import { HazelApp } from '@hazeljs/core';
+import { Type } from '@hazeljs/core';
+import { ServerlessEvent, ServerlessResponse, ServerlessContext } from './serverless.decorator';
+/**
+ * AWS Lambda event types
+ */
+export interface LambdaEvent extends ServerlessEvent {
+    resource?: string;
+    pathParameters?: Record<string, string>;
+    stageVariables?: Record<string, string>;
+    requestContext?: {
+        accountId: string;
+        apiId: string;
+        protocol: string;
+        httpMethod: string;
+        path: string;
+        stage: string;
+        requestId: string;
+        requestTime: string;
+        requestTimeEpoch: number;
+        identity: {
+            sourceIp: string;
+            userAgent: string;
+        };
+    };
+}
+/**
+ * AWS Lambda context
+ */
+export interface LambdaContext extends ServerlessContext {
+    awsRequestId: string;
+    invokedFunctionArn: string;
+    callbackWaitsForEmptyEventLoop: boolean;
+}
+/**
+ * Options for createLambdaHandler
+ */
+export interface LambdaHandlerOptions {
+    /** Called after the HazelJS app is initialized (e.g. for custom setup). */
+    onInit?: (app: HazelApp) => Promise<void>;
+    /** Called when the handler throws (e.g. for custom logging or reporting). */
+    onError?: (error: unknown) => void;
+    /** MIME types (e.g. 'image/png', 'image/*') that trigger base64 encoding of Buffer body for Lambda. */
+    binaryMimeTypes?: string[];
+}
+/**
+ * Lambda adapter for HazelJS
+ */
+export declare class LambdaAdapter {
+    private moduleClass;
+    private options;
+    private app?;
+    private optimizer;
+    private isColdStart;
+    constructor(moduleClass: Type<unknown>, options?: LambdaHandlerOptions);
+    /**
+     * Initialize the HazelJS application
+     */
+    private initialize;
+    /**
+     * Create Lambda handler
+     */
+    createHandler(): (event: LambdaEvent, context: LambdaContext) => Promise<ServerlessResponse>;
+    /**
+     * Convert Lambda event to HTTP request format
+     */
+    private convertLambdaEventToRequest;
+    /**
+     * Parse request body
+     */
+    private parseBody;
+    /**
+     * Process request through HazelJS router
+     */
+    private processRequest;
+    /**
+     * Whether the given Content-Type matches any of the binaryMimeTypes patterns.
+     */
+    private isBinaryContentType;
+    /**
+     * Get application instance
+     */
+    getApp(): HazelApp | undefined;
+    /**
+     * Check if this is a cold start
+     */
+    isCold(): boolean;
+}
+/**
+ * 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);
+ * ```
+ */
+export declare function createLambdaHandler(moduleClass: Type<unknown>, options?: LambdaHandlerOptions): (event: LambdaEvent, context: LambdaContext) => Promise<ServerlessResponse>;
+//# sourceMappingURL=lambda.adapter.d.ts.map

package/dist/lambda.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambda.adapter.d.ts","sourceRoot":"","sources":["../src/lambda.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErC,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EAElB,MAAM,wBAAwB,CAAC;AAGhC;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,eAAe;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,cAAc,CAAC,EAAE;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,gBAAgB,EAAE,MAAM,CAAC;QACzB,QAAQ,EAAE;YACR,QAAQ,EAAE,MAAM,CAAC;YACjB,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC;KACH,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,iBAAiB;IACtD,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,8BAA8B,EAAE,OAAO,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,6EAA6E;IAC7E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,uGAAuG;IACvG,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,aAAa;IAMtB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,OAAO;IANjB,OAAO,CAAC,GAAG,CAAC,CAAW;IACvB,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,WAAW,CAAQ;gBAGjB,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,GAAE,oBAAyB;IAK5C;;OAEG;YACW,UAAU;IAyBxB;;OAEG;IACH,aAAa,KACG,OAAO,WAAW,EAAE,SAAS,aAAa,KAAG,OAAO,CAAC,kBAAkB,CAAC;IAmCxF;;OAEG;IACH,OAAO,CAAC,2BAA2B;IA+BnC;;OAEG;IACH,OAAO,CAAC,SAAS;IAYjB;;OAEG;YACW,cAAc;IAqI5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;OAEG;IACH,MAAM,IAAI,QAAQ,GAAG,SAAS;IAI9B;;OAEG;IACH,MAAM,IAAI,OAAO;CAGlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAG7E"}

package/dist/lambda.adapter.js

@@ -0,0 +1,258 @@
+"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, options = {}) {
+        this.moduleClass = moduleClass;
+        this.options = options;
+        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);
+        if (this.options.onInit && this.app) {
+            await this.options.onInit(this.app);
+        }
+        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) {
+                this.options.onError?.(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: route.context?.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, route.context);
+            // If handler returned a value directly, use it
+            if (result !== undefined && responseBody === undefined) {
+                responseBody = result;
+            }
+            const contentType = responseHeaders['content-type'] ?? responseHeaders['Content-Type'] ?? '';
+            const isBinary = this.options.binaryMimeTypes?.length &&
+                this.isBinaryContentType(contentType) &&
+                (Buffer.isBuffer(responseBody) || responseBody instanceof Uint8Array);
+            let body;
+            let isBase64Encoded = false;
+            if (isBinary) {
+                body = Buffer.from(responseBody).toString('base64');
+                isBase64Encoded = true;
+            }
+            else {
+                body = typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody);
+            }
+            return {
+                statusCode: responseStatus,
+                body,
+                headers: responseHeaders,
+                ...(isBase64Encoded && { isBase64Encoded: true }),
+            };
+        }
+        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' },
+            };
+        }
+    }
+    /**
+     * Whether the given Content-Type matches any of the binaryMimeTypes patterns.
+     */
+    isBinaryContentType(contentType) {
+        if (!this.options.binaryMimeTypes?.length || !contentType)
+            return false;
+        const ct = contentType.split(';')[0].trim().toLowerCase();
+        for (const pattern of this.options.binaryMimeTypes) {
+            const p = pattern.toLowerCase();
+            if (p.endsWith('/*')) {
+                if (ct.startsWith(p.slice(0, -1)))
+                    return true;
+            }
+            else if (ct === p || ct.startsWith(p + '/')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 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, options) {
+    const adapter = new LambdaAdapter(moduleClass, options ?? {});
+    return adapter.createHandler();
+}