@hazeljs/serverless 0.2.0-beta.8 → 0.2.0-beta.81

package/dist/cold-start.optimizer.js

@@ -41,7 +41,8 @@ exports.OptimizeColdStart = OptimizeColdStart;
 const core_1 = __importDefault(require("@hazeljs/core"));
 const core_2 = require("@hazeljs/core");
 /**
- * Cold start optimization strategies
+ * Cold start optimization strategies.
+ * Best-effort and environment-dependent; preloads built-in modules and the DI container.
  */
 class ColdStartOptimizer {
     constructor() {
@@ -108,12 +109,10 @@ class ColdStartOptimizer {
         }
     }
     /**
-     * Setup connection pools
+     * Setup connection pools (placeholder; override or extend for DB/API connection warming).
      */
     async setupConnectionPools() {
         core_1.default.debug('Setting up connection pools...');
-        // Connection pools would be initialized here
-        // For now, just a placeholder
     }
     /**
      * Check if the application is warmed up
@@ -168,19 +167,20 @@ function OptimizeColdStart() {
     };
 }
 /**
- * Keep-alive helper to prevent cold starts
+ * Keep-alive helper to schedule periodic pings.
+ * Does not perform an HTTP request; use a cron, external pinger, or implement fetch/http.get in the interval
+ * to actually warm the function.
  */
 class KeepAliveHelper {
     /**
-     * Start keep-alive pings
+     * Start keep-alive interval (logs only; implement your own HTTP ping or use provisioned concurrency for warming).
      */
     start(url, intervalMs = 5 * 60 * 1000) {
         this.pingUrl = url;
         this.intervalId = setInterval(async () => {
             try {
                 core_1.default.debug(`Sending keep-alive ping to ${url}`);
-                // In a real implementation, you would make an HTTP request here
-                // For now, just log it
+                // Implement fetch(url) or http.get(url) here to actually warm the function
             }
             catch (error) {
                 core_1.default.error('Keep-alive ping failed:', error);

package/dist/index.d.ts

@@ -3,6 +3,6 @@
  */
 export { Serverless, getServerlessMetadata, isServerless, type ServerlessOptions, type ServerlessHandler, type ServerlessContext, type ServerlessEvent, type ServerlessResponse, } from './serverless.decorator';
 export { ColdStartOptimizer, OptimizeColdStart, KeepAliveHelper } from './cold-start.optimizer';
-export { LambdaAdapter, createLambdaHandler, type LambdaEvent, type LambdaContext, } from './lambda.adapter';
-export { CloudFunctionAdapter, createCloudFunctionHandler, createCloudFunctionEventHandler, type CloudFunctionRequest, type CloudFunctionResponse, } from './cloud-function.adapter';
+export { LambdaAdapter, createLambdaHandler, type LambdaEvent, type LambdaContext, type LambdaHandlerOptions, } from './lambda.adapter';
+export { CloudFunctionAdapter, createCloudFunctionHandler, createCloudFunctionEventHandler, type CloudFunctionRequest, type CloudFunctionResponse, type CloudFunctionHandlerOptions, } from './cloud-function.adapter';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,kBAAkB,GACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,kBAAkB,GACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,+BAA+B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,GACjC,MAAM,0BAA0B,CAAC"}

package/dist/integration.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Integration tests: real HazelJS app through Lambda and Cloud Function adapters.
+ * No mocks of @hazeljs/core — uses real HazelApp, router, and controllers.
+ */
+import 'reflect-metadata';
+//# sourceMappingURL=integration.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../src/integration.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,kBAAkB,CAAC"}

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

@@ -32,15 +32,27 @@ export interface LambdaContext extends ServerlessContext {
     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>);
+    constructor(moduleClass: Type<unknown>, options?: LambdaHandlerOptions);
     /**
      * Initialize the HazelJS application
      */
@@ -61,6 +73,10 @@ export declare class LambdaAdapter {
      * Process request through HazelJS router
      */
     private processRequest;
+    /**
+     * Whether the given Content-Type matches any of the binaryMimeTypes patterns.
+     */
+    private isBinaryContentType;
     /**
      * Get application instance
      */
@@ -82,5 +98,5 @@ export declare class LambdaAdapter {
  * export const handler = createLambdaHandler(AppModule);
  * ```
  */
-export declare function createLambdaHandler(moduleClass: Type<unknown>): (event: LambdaEvent, context: LambdaContext) => Promise<ServerlessResponse>;
+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

@@ -1 +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,qBAAa,aAAa;IAKZ,OAAO,CAAC,WAAW;IAJ/B,OAAO,CAAC,GAAG,CAAC,CAAW;IACvB,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,WAAW,CAAQ;gBAEP,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC;IAI9C;;OAEG;YACW,UAAU;IAqBxB;;OAEG;IACH,aAAa,KACG,OAAO,WAAW,EAAE,SAAS,aAAa,KAAG,OAAO,CAAC,kBAAkB,CAAC;IAkCxF;;OAEG;IACH,OAAO,CAAC,2BAA2B;IA+BnC;;OAEG;IACH,OAAO,CAAC,SAAS;IAYjB;;OAEG;YACW,cAAc;IAiH5B;;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,GACzB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAG7E"}
+{"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

@@ -13,8 +13,9 @@ const cold_start_optimizer_1 = require("./cold-start.optimizer");
  * Lambda adapter for HazelJS
  */
 class LambdaAdapter {
-    constructor(moduleClass) {
+    constructor(moduleClass, options = {}) {
         this.moduleClass = moduleClass;
+        this.options = options;
         this.isColdStart = true;
         this.optimizer = cold_start_optimizer_1.ColdStartOptimizer.getInstance();
     }
@@ -34,6 +35,9 @@ class LambdaAdapter {
         }
         // 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`);
     }
@@ -57,6 +61,7 @@ class LambdaAdapter {
                 return response;
             }
             catch (error) {
+                this.options.onError?.(error);
                 core_2.default.error('Lambda handler error:', error);
                 return {
                     statusCode: 500,
@@ -141,7 +146,7 @@ class LambdaAdapter {
                 url: request.url,
                 headers: request.headers,
                 query: request.query,
-                params: context.params || {},
+                params: route.context?.params ?? context.params ?? {},
                 body: request.body,
             };
             let responseBody;
@@ -167,15 +172,29 @@ class LambdaAdapter {
                     return responseHeaders[key];
                 },
             };
-            const result = await route.handler(syntheticReq, syntheticRes);
+            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: typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody),
+                body,
                 headers: responseHeaders,
+                ...(isBase64Encoded && { isBase64Encoded: true }),
             };
         }
         catch (error) {
@@ -188,6 +207,25 @@ class LambdaAdapter {
             };
         }
     }
+    /**
+     * 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
      */
@@ -214,7 +252,7 @@ exports.LambdaAdapter = LambdaAdapter;
  * export const handler = createLambdaHandler(AppModule);
  * ```
  */
-function createLambdaHandler(moduleClass) {
-    const adapter = new LambdaAdapter(moduleClass);
+function createLambdaHandler(moduleClass, options) {
+    const adapter = new LambdaAdapter(moduleClass, options ?? {});
     return adapter.createHandler();
 }

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":""}