@hazeljs/serverless 0.2.0-beta.70 → 0.2.0-beta.72

package/README.md

@@ -167,6 +167,8 @@ export const hazelApp = createCloudFunctionHandler(AppModule, {
 });
 ```
 
+**Event handler (Pub/Sub, Storage):** `createCloudFunctionEventHandler(Module)` returns a stub that initializes the app and logs the event but does not route to user code. Implement your own event handling and call it from that handler, or use a separate entrypoint for event-triggered functions.
+
 ### Deployment
 
 #### Using gcloud CLI
@@ -204,36 +206,28 @@ gcloud functions deploy hazeljs-app --config function.yaml
 
 ## Decorator-Based Optimization
 
-Mark routes for serverless optimization:
+Mark **controllers** (classes) for serverless optimization with `@Serverless`:
 
 ```typescript
 import { Controller, Get } from '@hazeljs/core';
 import { Serverless } from '@hazeljs/serverless';
 
 @Controller('/api')
+@Serverless({ memory: 512, timeout: 30, coldStartOptimization: true })
 export class ApiController {
   @Get('/hello')
-  @Serverless({ optimize: true })
   hello() {
     return { message: 'Hello from serverless!' };
   }
-
-  @Get('/data')
-  @Serverless({
-    optimize: true,
-    cache: {
-      enabled: true,
-      ttl: 300, // 5 minutes
-    },
-  })
-  getData() {
-    return { data: 'cached response' };
-  }
 }
 ```
 
+> **Note:** The decorator is class-level only. Method-level `@Serverless({ optimize, cache })` and per-route `binaryResponse` are planned for a future release.
+
 ## Cold Start Optimization
 
+**ColdStartOptimizer** preloads the DI container and built-in modules (http, https, crypto, buffer); behavior is best-effort and may vary by Node version. **KeepAliveHelper** runs an interval but does not perform an actual HTTP request—use provisioned concurrency, a cron job, or implement `fetch`/`http.get` in the interval to warm the function.
+
 ### Minimize Bundle Size
 
 ```typescript
@@ -328,14 +322,12 @@ getLambdaInfo(@Req() req: any) {
 
 ### Binary Responses
 
+You can pass `binaryMimeTypes` in `createLambdaHandler` options for future use. Automatic base64 encoding of binary response bodies for Lambda is planned.
+
 ```typescript
-@Get('/image')
-@Serverless({ binaryResponse: true })
-async getImage(@Res() res: Response) {
-  const image = await fs.readFile('image.png');
-  res.setHeader('Content-Type', 'image/png');
-  res.send(image);
-}
+export const handler = createLambdaHandler(AppModule, {
+  binaryMimeTypes: ['image/png', 'application/pdf'],
+});
 ```
 
 ## Logging

package/dist/adapters.test.js

@@ -134,6 +134,22 @@ describe('LambdaAdapter', () => {
             const result = await new lambda_adapter_1.LambdaAdapter(MockModule).createHandler()(makeEvent(), makeContext());
             expect(result.statusCode).toBe(500);
         });
+        it('returns base64 body and isBase64Encoded when binaryMimeTypes matches and handler sends Buffer', async () => {
+            const binaryPayload = Buffer.from('fake-png-bytes');
+            mockMatch.mockResolvedValue({
+                handler: async (_req, res) => {
+                    res.setHeader('Content-Type', 'image/png');
+                    res.send(binaryPayload);
+                },
+            });
+            const adapter = new lambda_adapter_1.LambdaAdapter(MockModule, {
+                binaryMimeTypes: ['image/png', 'image/*'],
+            });
+            const result = await adapter.createHandler()(makeEvent(), makeContext());
+            expect(result.statusCode).toBe(200);
+            expect(result.isBase64Encoded).toBe(true);
+            expect(Buffer.from(result.body, 'base64').toString()).toBe('fake-png-bytes');
+        });
     });
     describe('createHandler() – request conversion', () => {
         it('parses JSON body', async () => {

package/dist/cloud-function.adapter.d.ts

@@ -22,15 +22,25 @@ export interface CloudFunctionResponse {
     json(body: unknown): void;
     end(): void;
 }
+/**
+ * Options for createCloudFunctionHandler
+ */
+export interface CloudFunctionHandlerOptions {
+    /** Called after the HazelJS app is initialized. */
+    onInit?: (app: HazelApp) => Promise<void>;
+    /** Called when the handler throws. */
+    onError?: (error: unknown) => void;
+}
 /**
  * Cloud Function adapter for HazelJS
  */
 export declare class CloudFunctionAdapter {
     private moduleClass;
+    private options;
     private app?;
     private optimizer;
     private isColdStart;
-    constructor(moduleClass: Type<unknown>);
+    constructor(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions);
     /**
      * Initialize the HazelJS application
      */
@@ -40,7 +50,9 @@ export declare class CloudFunctionAdapter {
      */
     createHttpHandler(): (req: CloudFunctionRequest, res: CloudFunctionResponse) => Promise<void>;
     /**
-     * Create Cloud Function event handler (for Pub/Sub, Storage, etc.)
+     * Create Cloud Function event handler (for Pub/Sub, Storage, etc.).
+     * Stub: initializes the app and logs the event but does not route to user-defined handlers.
+     * Implement custom event handling in your module or a separate entrypoint and invoke it from here.
      */
     createEventHandler(): (event: unknown, context: unknown) => Promise<void>;
     /**
@@ -80,7 +92,7 @@ export declare class CloudFunctionAdapter {
  * export const handler = createCloudFunctionHandler(AppModule);
  * ```
  */
-export declare function createCloudFunctionHandler(moduleClass: Type<unknown>): (req: CloudFunctionRequest, res: CloudFunctionResponse) => Promise<void>;
+export declare function createCloudFunctionHandler(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions): (req: CloudFunctionRequest, res: CloudFunctionResponse) => Promise<void>;
 /**
  * Create a Cloud Function event handler for a HazelJS module
  *
@@ -93,5 +105,5 @@ export declare function createCloudFunctionHandler(moduleClass: Type<unknown>):
  * export const handler = createCloudFunctionEventHandler(AppModule);
  * ```
  */
-export declare function createCloudFunctionEventHandler(moduleClass: Type<unknown>): (event: unknown, context: unknown) => Promise<void>;
+export declare function createCloudFunctionEventHandler(moduleClass: Type<unknown>, options?: CloudFunctionHandlerOptions): (event: unknown, context: unknown) => Promise<void>;
 //# sourceMappingURL=cloud-function.adapter.d.ts.map

package/dist/cloud-function.adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloud-function.adapter.d.ts","sourceRoot":"","sources":["../src/cloud-function.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKrC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;IAC5C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC;IACzD,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,GAAG,IAAI,IAAI,CAAC;CACb;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAKnB,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,iBAAiB,KACD,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,KAAG,OAAO,CAAC,IAAI,CAAC;IAqCrF;;OAEG;IACH,kBAAkB,KACF,OAAO,OAAO,EAAE,SAAS,OAAO,KAAG,OAAO,CAAC,IAAI,CAAC;IA0BhE;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAoBnC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;YACW,cAAc;IA2G5B;;OAEG;IACH,MAAM,IAAI,QAAQ,GAAG,SAAS;IAI9B;;OAEG;IACH,MAAM,IAAI,OAAO;CAGlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,GACzB,CAAC,GAAG,EAAE,oBAAoB,EAAE,GAAG,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAG1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,GACzB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAGrD"}
+{"version":3,"file":"cloud-function.adapter.d.ts","sourceRoot":"","sources":["../src/cloud-function.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKrC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;IAC5C,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC;IACzD,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,GAAG,IAAI,IAAI,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,mDAAmD;IACnD,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,sCAAsC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAM7B,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,2BAAgC;IAKnD;;OAEG;YACW,UAAU;IAyBxB;;OAEG;IACH,iBAAiB,KACD,KAAK,oBAAoB,EAAE,KAAK,qBAAqB,KAAG,OAAO,CAAC,IAAI,CAAC;IAsCrF;;;;OAIG;IACH,kBAAkB,KACF,OAAO,OAAO,EAAE,SAAS,OAAO,KAAG,OAAO,CAAC,IAAI,CAAC;IA0BhE;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAoBnC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;YACW,cAAc;IA+G5B;;OAEG;IACH,MAAM,IAAI,QAAQ,GAAG,SAAS;IAI9B;;OAEG;IACH,MAAM,IAAI,OAAO;CAGlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,2BAA2B,GACpC,CAAC,GAAG,EAAE,oBAAoB,EAAE,GAAG,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,CAG1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,EAC1B,OAAO,CAAC,EAAE,2BAA2B,GACpC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAGrD"}

package/dist/cloud-function.adapter.js

@@ -14,8 +14,9 @@ const cold_start_optimizer_1 = require("./cold-start.optimizer");
  * Cloud Function adapter for HazelJS
  */
 class CloudFunctionAdapter {
-    constructor(moduleClass) {
+    constructor(moduleClass, options = {}) {
         this.moduleClass = moduleClass;
+        this.options = options;
         this.isColdStart = true;
         this.optimizer = cold_start_optimizer_1.ColdStartOptimizer.getInstance();
     }
@@ -35,6 +36,9 @@ class CloudFunctionAdapter {
         }
         // 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(`Cloud Function initialization completed in ${duration}ms`);
     }
@@ -65,6 +69,7 @@ class CloudFunctionAdapter {
                 res.send(response.body);
             }
             catch (error) {
+                this.options.onError?.(error);
                 core_2.default.error('Cloud Function handler error:', error);
                 res.status(500).json({
                     error: 'Internal Server Error',
@@ -74,7 +79,9 @@ class CloudFunctionAdapter {
         };
     }
     /**
-     * Create Cloud Function event handler (for Pub/Sub, Storage, etc.)
+     * Create Cloud Function event handler (for Pub/Sub, Storage, etc.).
+     * Stub: initializes the app and logs the event but does not route to user-defined handlers.
+     * Implement custom event handling in your module or a separate entrypoint and invoke it from here.
      */
     createEventHandler() {
         return async (event, context) => {
@@ -90,11 +97,11 @@ class CloudFunctionAdapter {
                     eventType: context.eventType,
                     resource: context.resource,
                 });
-                // Process event
-                // In a real implementation, this would route to appropriate handlers
+                // Stub: extend this to dispatch event to your handlers (e.g. Pub/Sub, Storage)
                 core_2.default.info('Event processed successfully');
             }
             catch (error) {
+                this.options.onError?.(error);
                 core_2.default.error('Cloud Function event handler error:', error);
                 throw error;
             }
@@ -170,7 +177,7 @@ class CloudFunctionAdapter {
                 url: request.url,
                 headers: request.headers,
                 query: request.query,
-                params: context.params || {},
+                params: route.context?.params ?? context.params ?? {},
                 body: request.body,
             };
             let responseBody;
@@ -196,7 +203,7 @@ class CloudFunctionAdapter {
                     return responseHeaders[key];
                 },
             };
-            const result = await route.handler(syntheticReq, syntheticRes);
+            const result = await route.handler(syntheticReq, syntheticRes, route.context);
             if (result !== undefined && responseBody === undefined) {
                 responseBody = result;
             }
@@ -242,8 +249,8 @@ exports.CloudFunctionAdapter = CloudFunctionAdapter;
  * export const handler = createCloudFunctionHandler(AppModule);
  * ```
  */
-function createCloudFunctionHandler(moduleClass) {
-    const adapter = new CloudFunctionAdapter(moduleClass);
+function createCloudFunctionHandler(moduleClass, options) {
+    const adapter = new CloudFunctionAdapter(moduleClass, options ?? {});
     return adapter.createHttpHandler();
 }
 /**
@@ -258,7 +265,7 @@ function createCloudFunctionHandler(moduleClass) {
  * export const handler = createCloudFunctionEventHandler(AppModule);
  * ```
  */
-function createCloudFunctionEventHandler(moduleClass) {
-    const adapter = new CloudFunctionAdapter(moduleClass);
+function createCloudFunctionEventHandler(moduleClass, options) {
+    const adapter = new CloudFunctionAdapter(moduleClass, options ?? {});
     return adapter.createEventHandler();
 }

package/dist/cold-start.optimizer.d.ts

@@ -1,5 +1,6 @@
 /**
- * Cold start optimization strategies
+ * Cold start optimization strategies.
+ * Best-effort and environment-dependent; preloads built-in modules and the DI container.
  */
 export declare class ColdStartOptimizer {
     private static instance;
@@ -21,7 +22,7 @@ export declare class ColdStartOptimizer {
      */
     private preloadCriticalModules;
     /**
-     * Setup connection pools
+     * Setup connection pools (placeholder; override or extend for DB/API connection warming).
      */
     private setupConnectionPools;
     /**
@@ -50,13 +51,15 @@ export declare class ColdStartOptimizer {
  */
 export declare function OptimizeColdStart(): MethodDecorator;
 /**
- * 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.
  */
 export declare class KeepAliveHelper {
     private intervalId?;
     private pingUrl?;
     /**
-     * Start keep-alive pings
+     * Start keep-alive interval (logs only; implement your own HTTP ping or use provisioned concurrency for warming).
      */
     start(url: string, intervalMs?: number): void;
     /**

package/dist/cold-start.optimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cold-start.optimizer.d.ts","sourceRoot":"","sources":["../src/cold-start.optimizer.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,kBAAkB;IAOxC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B7B;;OAEG;YACW,sBAAsB;IAOpC;;OAEG;YACW,sBAAsB;IAgBpC;;OAEG;YACW,oBAAoB;IAMlC;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,kBAAkB,IAAI,MAAM,GAAG,SAAS;IAIxC;;OAEG;IACH,iBAAiB,IAAI,MAAM,GAAG,SAAS;IAKvC;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;CAGhC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,eAAe,CAgBnD;AAED;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAC,CAAiB;IACpC,OAAO,CAAC,OAAO,CAAC,CAAS;IAEzB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAsB,GAAG,IAAI;IAgB5D;;OAEG;IACH,IAAI,IAAI,IAAI;CAOb"}
+{"version":3,"file":"cold-start.optimizer.d.ts","sourceRoot":"","sources":["../src/cold-start.optimizer.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,kBAAkB;IAOxC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B7B;;OAEG;YACW,sBAAsB;IAOpC;;OAEG;YACW,sBAAsB;IAgBpC;;OAEG;YACW,oBAAoB;IAIlC;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,kBAAkB,IAAI,MAAM,GAAG,SAAS;IAIxC;;OAEG;IACH,iBAAiB,IAAI,MAAM,GAAG,SAAS;IAKvC;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;CAGhC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,eAAe,CAgBnD;AAED;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAAC,CAAiB;IACpC,OAAO,CAAC,OAAO,CAAC,CAAS;IAEzB;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAsB,GAAG,IAAI;IAe5D;;OAEG;IACH,IAAI,IAAI,IAAI;CAOb"}

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

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/serverless",
-  "version": "0.2.0-beta.70",
+  "version": "0.2.0-beta.72",
   "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": "ff7e43369af054d18e064bb342d1e6c5f058ca87"
+  "gitHead": "04468cb4dddc7a4faf829af5c5410a85cae14d74"
 }