lambder 1.0.128 → 1.0.130

package/OUTPUT_TYPE_ENFORCEMENT_SUMMARY.md

@@ -0,0 +1,90 @@
+# Output Type Enforcement - Implementation Summary
+
+## Problem
+The type system was only enforcing input types for `ctx.apiPayload`, but not enforcing that the output returned by `resolver.api()` matched the contract's output type.
+
+## Solution
+Made the following components generic to propagate type information:
+
+### 1. LambderResponseBuilder
+- Added generic parameter: `LambderResponseBuilder<TContract extends ApiContractShape = any>`
+- The `api()` method now uses the generic type for type checking
+
+### 2. LambderResolver
+- Added generic parameters: `LambderResolver<TContract extends ApiContractShape = any, TApiName extends keyof TContract & string = any>`
+- Overrides the `api()` method to enforce output type: `api(payload: ApiOutput<TContract, TApiName> | null, ...)`
+- The `die.api()` method also enforces the output type through the interface
+
+### 3. Lambder addApi/addSessionApi
+- Updated type signatures to pass `LambderResolver<TContract, TApiName>` to the action function
+- Now both methods enforce:
+  - ✅ Input type via `ctx.apiPayload: TContract[TApiName]['input']`
+  - ✅ Output type via `resolver.api(payload: TContract[TApiName]['output'] | null)`
+
+## Type Flow
+```
+Contract Definition
+    ↓
+Lambder<TContract>
+    ↓
+addApi<TApiName>(apiName, actionFn)
+    ↓
+actionFn(ctx: LambderRenderContext<Input>, resolver: LambderResolver<TContract, TApiName>)
+    ↓
+resolver.api(payload: Output | null)
+    ↓
+Type validation at compile time!
+```
+
+## What's Enforced Now
+
+### Input Types (already working)
+```typescript
+lambder.addApi('getUserById', async (ctx, resolver) => {
+    ctx.apiPayload.userId; // ✅ TypeScript knows this is string
+});
+```
+
+### Output Types (NEW!)
+```typescript
+lambder.addApi('getUserById', async (ctx, resolver) => {
+    const user = { id: "123", name: "John", age: 30 };
+    return resolver.api(user); // ✅ TypeScript validates user matches User type
+    
+    // return resolver.api("wrong"); // ❌ TypeScript error!
+});
+```
+
+## Features
+- ✅ Works with `resolver.api()`
+- ✅ Works with `resolver.die.api()`
+- ✅ Works with `addApi()`
+- ✅ Works with `addSessionApi()`
+- ✅ Supports nullable outputs (`output: User | null`)
+- ✅ Supports complex nested types
+- ✅ Supports arrays
+- ✅ Supports primitive types
+- ✅ Zero runtime overhead - all validation is at compile time
+- ✅ Backward compatible - untyped APIs still work
+
+## Files Changed
+1. `src/LambderResponseBuilder.ts` - Made generic, imported ApiContractShape
+2. `src/LambderResolver.ts` - Made generic, added typed `api()` override
+3. `src/Lambder.ts` - Updated addApi/addSessionApi type signatures
+4. `docs/TYPE_SAFE_QUICK_START.md` - Updated documentation with output type examples
+
+## Examples Created
+1. `examples/test-output-type-enforcement.ts` - Unit test for type enforcement
+2. `examples/output-type-enforcement-example.ts` - Comprehensive demonstration
+
+## Testing
+All existing examples and tests compile without errors:
+- ✅ `examples/simplified-typed-api-example.ts`
+- ✅ `tests/type-safety.test.ts`
+- ✅ No TypeScript compilation errors in project
+
+## Backward Compatibility
+The changes are fully backward compatible:
+- Untyped usage still works: `new Lambder({ ... })` without generic
+- Typed usage is opt-in: `new Lambder<MyContract>({ ... })`
+- Existing code continues to work unchanged

package/Readme.md

@@ -5,9 +5,11 @@ Lambder is a highly opinionated dynamic serverless framework designed to facilit
 ## Features
 
 - **Simple API & Route Declaration**: Define your APIs and routes using concise and expressive syntax.
+- **Type-Safe API Contracts**: Full TypeScript type safety across frontend and backend with zero runtime overhead.
 - **Session Management**: Built-in session management to secure and personalize user experiences.
 - **Flexible Hooks System**: Employ hooks to execute code at different stages of the request lifecycle, enabling fine-grained control over the application flow.
 - **Error Handling**: Comprehensive error handling capabilities, including global error handlers and route-specific fallbacks.
+- **MSW Mocking Support**: Optional Mock Service Worker integration for easy API mocking in tests and development.
 - **Seamless Integration**: Designed to work effortlessly with AWS Lambda and API Gateway, providing a straightforward path to deploy serverless applications.
 
 ## Installation
@@ -544,6 +546,53 @@ const user = await caller.api('getUserById', { userId: '123' });
 
 📖 **[Read the Quick Start Guide](docs/TYPE_SAFE_QUICK_START.md)** for more details and examples!
 
+## Testing & Mocking with MSW
+
+Lambder provides optional integration with [Mock Service Worker (MSW)](https://mswjs.io/) for easy API mocking in tests and development.
+
+### Installation
+
+```bash
+npm install --save-dev msw
+```
+
+### Quick Example
+
+```typescript
+import { mockLambderApi } from 'lambder';
+import { setupServer } from 'msw/node';
+import type { MyApiContract } from './apiContract';
+
+// Create type-safe mock handlers
+const handlers = [
+  mockLambderApi<MyApiContract, 'getUserById'>(
+    'getUserById',
+    (input) => ({
+      id: input.userId,
+      name: 'Test User',
+      email: 'test@example.com'
+    })
+  )
+];
+
+// Set up MSW server
+const server = setupServer(...handlers);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+```
+
+### Benefits
+
+✅ **Type-Safe Mocking** - Full TypeScript support for mock responses  
+✅ **Easy Setup** - Simple functions that match your API contract  
+✅ **Test Scenarios** - Mock errors, session expired, not authorized, etc.  
+✅ **Development Mode** - Use mocks while developing frontend features  
+✅ **Storybook Ready** - Perfect for component stories  
+
+📖 **[Read the MSW Mocking Guide](docs/MSW_MOCKING.md)** for detailed setup and examples!
+
 ## Contributing
 
 Contributions are welcome! Especially for documentation. If you have an idea for an improvement or have found a bug, please open an issue or submit a pull request.

package/dist/Lambder.d.ts

@@ -66,10 +66,11 @@ export default class Lambder<TContract extends ApiContractShape = any> {
         apiVersion?: string;
     });
     enableCors(isCorsEnabled: boolean): void;
-    enableDdbSession({ tableName, tableRegion, sessionSalt }: {
+    enableDdbSession({ tableName, tableRegion, sessionSalt, enableSlidingExpiration }: {
         tableName: string;
         tableRegion: string;
         sessionSalt: string;
+        enableSlidingExpiration?: boolean;
     }, { partitionKey, sortKey }?: {
         partitionKey: string;
         sortKey: string;
@@ -88,17 +89,17 @@ export default class Lambder<TContract extends ApiContractShape = any> {
     addRoute(condition: Path | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addSessionRoute(condition: Path | ConditionFunction | RegExp, actionFn: ActionFunction): void;
     addApi(apiName: ConditionFunction | RegExp, actionFn: ActionFunction): void;
-    addApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderRenderContext<TContract[TApiName]['input']>, resolver: LambderResolver) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
+    addApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderRenderContext<TContract[TApiName]['input']>, resolver: LambderResolver<TContract, TApiName>) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
     addApi(apiName: string, actionFn: ActionFunction): void;
     addSessionApi(apiName: ConditionFunction | RegExp, actionFn: ActionFunction): void;
-    addSessionApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderRenderContext<TContract[TApiName]['input']>, resolver: LambderResolver) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
+    addSessionApi<TApiName extends keyof TContract & string>(apiName: TApiName, actionFn: (ctx: LambderRenderContext<TContract[TApiName]['input']>, resolver: LambderResolver<TContract, TApiName>) => LambderResolverResponse | Promise<LambderResolverResponse>): void;
     addSessionApi(apiName: string, actionFn: ActionFunction): void;
     addHook(hookEvent: 'created', hookFn: HookCreatedFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'beforeRender', hookFn: HookBeforeRenderFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'afterRender', hookFn: HookAfterRenderFunction, priority?: number): Promise<void>;
     addHook(hookEvent: 'fallback', hookFn: HookFallbackFunction, priority?: number): Promise<void>;
     getSessionController(ctx: LambderRenderContext<any>): LambderSessionController;
-    getResponseBuilder(): LambderResponseBuilder;
+    getResponseBuilder(): LambderResponseBuilder<any>;
     private getResolver;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<LambderResolverResponse>;
 }

package/dist/Lambder.js

@@ -75,9 +75,9 @@ export default class Lambder {
     enableCors(isCorsEnabled) {
         this.isCorsEnabled = isCorsEnabled;
     }
-    enableDdbSession({ tableName, tableRegion, sessionSalt }, { partitionKey, sortKey } = { partitionKey: "pk", sortKey: "sk" }) {
+    enableDdbSession({ tableName, tableRegion, sessionSalt, enableSlidingExpiration }, { partitionKey, sortKey } = { partitionKey: "pk", sortKey: "sk" }) {
         this.lambderSessionManager = new LambderSessionManager({
-            tableName, tableRegion, partitionKey, sortKey, sessionSalt
+            tableName, tableRegion, partitionKey, sortKey, sessionSalt, enableSlidingExpiration
         });
     }
     setSessionCookieKey(sessionTokenCookieKey, sessionCsrfCookieKey) {

package/dist/LambderMSW.d.ts

@@ -0,0 +1,104 @@
+import type { ApiContractShape } from './LambderApiContract.js';
+export type HttpHandler = (info: any) => Promise<Response | undefined> | Response | undefined;
+/**
+ * Creates a mock handler for a Lambder API endpoint
+ *
+ * @example
+ * ```typescript
+ * mockLambderApi('public.getInitialPageData', () => ({
+ *   userLocationData: { ... },
+ *   sessionUser: null
+ * }))
+ * ```
+ *
+ * @example with dynamic response based on input
+ * ```typescript
+ * mockLambderApi('user.updateProfile', (input) => ({
+ *   success: true,
+ *   userId: input.userId
+ * }))
+ * ```
+ */
+export declare function mockLambderApi<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, responseFactory: (input: TContract[TApiName]['input']) => TContract[TApiName]['output'] | Promise<TContract[TApiName]['output']>, options?: {
+    /** Custom API path, defaults to '/api' */
+    apiPath?: string;
+    /** Delay in ms before responding (for testing loading states) */
+    delay?: number;
+    /** Custom apiVersion to include in response */
+    apiVersion?: string | null;
+}): HttpHandler;
+/**
+ * Creates a mock handler that returns an error for a Lambder API endpoint
+ *
+ * @example
+ * ```typescript
+ * mockLambderApiError('user.deleteAccount', 'Account deletion failed')
+ * ```
+ */
+export declare function mockLambderApiError<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, errorMessage: string, options?: {
+    /** Custom API path, defaults to '/api' */
+    apiPath?: string;
+    /** Delay in ms before responding */
+    delay?: number;
+    /** Custom apiVersion to include in response */
+    apiVersion?: string | null;
+}): HttpHandler;
+/**
+ * Creates a mock handler that simulates a session expired error
+ *
+ * @example
+ * ```typescript
+ * mockLambderSessionExpired('user.updateProfile')
+ * ```
+ */
+export declare function mockLambderSessionExpired<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
+    /** Custom API path, defaults to '/api' */
+    apiPath?: string;
+    /** Custom apiVersion to include in response */
+    apiVersion?: string | null;
+}): HttpHandler;
+/**
+ * Creates a mock handler that simulates a "not authorized" error
+ *
+ * @example
+ * ```typescript
+ * mockLambderNotAuthorized('admin.deleteUser')
+ * ```
+ */
+export declare function mockLambderNotAuthorized<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
+    /** Custom API path, defaults to '/api' */
+    apiPath?: string;
+    /** Custom apiVersion to include in response */
+    apiVersion?: string | null;
+}): HttpHandler;
+/**
+ * Creates a mock handler that simulates a version expired error
+ *
+ * @example
+ * ```typescript
+ * mockLambderVersionExpired('user.updateProfile')
+ * ```
+ */
+export declare function mockLambderVersionExpired<TContract extends ApiContractShape, TApiName extends keyof TContract & string>(apiName: TApiName, options?: {
+    /** Custom API path, defaults to '/api' */
+    apiPath?: string;
+    /** Custom apiVersion to include in response */
+    apiVersion?: string | null;
+}): HttpHandler;
+/**
+ * Helper function to create the MSW http.post handler with proper path matching
+ * This is useful when you need to set up multiple handlers with the same path
+ *
+ * @example
+ * ```typescript
+ * import { setupServer } from 'msw/node';
+ *
+ * const server = setupServer(
+ *   createLambderApiHandler('/api', [
+ *     mockLambderApi('user.getProfile', () => ({ name: 'Test User' })),
+ *     mockLambderApi('user.updateProfile', (input) => ({ success: true }))
+ *   ])
+ * );
+ * ```
+ */
+export declare function createLambderApiHandler(apiPath: string, handlers: HttpHandler[]): HttpHandler;

package/dist/LambderMSW.js

@@ -0,0 +1,203 @@
+// Dynamic imports to avoid requiring MSW as a hard dependency
+let http;
+let HttpResponse;
+/**
+ * Initialize MSW dependencies dynamically
+ * This allows the module to be imported even if MSW is not installed
+ */
+async function ensureMSW() {
+    if (!http || !HttpResponse) {
+        try {
+            // @ts-ignore - MSW is an optional peer dependency
+            const msw = await import('msw');
+            http = msw.http;
+            HttpResponse = msw.HttpResponse;
+        }
+        catch (err) {
+            throw new Error('MSW is required to use Lambder mocking utilities. ' +
+                'Install it with: npm install --save-dev msw');
+        }
+    }
+}
+/**
+ * Creates a mock handler for a Lambder API endpoint
+ *
+ * @example
+ * ```typescript
+ * mockLambderApi('public.getInitialPageData', () => ({
+ *   userLocationData: { ... },
+ *   sessionUser: null
+ * }))
+ * ```
+ *
+ * @example with dynamic response based on input
+ * ```typescript
+ * mockLambderApi('user.updateProfile', (input) => ({
+ *   success: true,
+ *   userId: input.userId
+ * }))
+ * ```
+ */
+export function mockLambderApi(apiName, responseFactory, options) {
+    const apiPath = options?.apiPath ?? '/api';
+    const delay = options?.delay ?? 0;
+    const apiVersion = options?.apiVersion ?? null;
+    // Return a handler that will be initialized when MSW is available
+    return (async ({ request }) => {
+        await ensureMSW();
+        const body = (await request.json());
+        // Only handle this specific API
+        if (body.apiName !== apiName) {
+            return;
+        }
+        console.log(`[MSW Lambder] Mocking ${apiName}`, body.payload);
+        // Apply delay if specified
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        // Generate the response
+        const payload = await responseFactory(body.payload);
+        // Return in Lambder API response format
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload,
+        });
+    });
+}
+/**
+ * Creates a mock handler that returns an error for a Lambder API endpoint
+ *
+ * @example
+ * ```typescript
+ * mockLambderApiError('user.deleteAccount', 'Account deletion failed')
+ * ```
+ */
+export function mockLambderApiError(apiName, errorMessage, options) {
+    const apiPath = options?.apiPath ?? '/api';
+    const delay = options?.delay ?? 0;
+    const apiVersion = options?.apiVersion ?? null;
+    return (async ({ request }) => {
+        await ensureMSW();
+        const body = (await request.json());
+        if (body.apiName !== apiName) {
+            return;
+        }
+        console.log(`[MSW Lambder] Mocking error for ${apiName}:`, errorMessage);
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload: null,
+            errorMessage,
+        });
+    });
+}
+/**
+ * Creates a mock handler that simulates a session expired error
+ *
+ * @example
+ * ```typescript
+ * mockLambderSessionExpired('user.updateProfile')
+ * ```
+ */
+export function mockLambderSessionExpired(apiName, options) {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+    return (async ({ request }) => {
+        await ensureMSW();
+        const body = (await request.json());
+        if (body.apiName !== apiName) {
+            return;
+        }
+        console.log(`[MSW Lambder] Mocking session expired for ${apiName}`);
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload: null,
+            sessionExpired: true,
+            errorMessage: 'Session expired',
+        });
+    });
+}
+/**
+ * Creates a mock handler that simulates a "not authorized" error
+ *
+ * @example
+ * ```typescript
+ * mockLambderNotAuthorized('admin.deleteUser')
+ * ```
+ */
+export function mockLambderNotAuthorized(apiName, options) {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+    return (async ({ request }) => {
+        await ensureMSW();
+        const body = (await request.json());
+        if (body.apiName !== apiName) {
+            return;
+        }
+        console.log(`[MSW Lambder] Mocking not authorized for ${apiName}`);
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload: null,
+            notAuthorized: true,
+            errorMessage: 'Not authorized',
+        });
+    });
+}
+/**
+ * Creates a mock handler that simulates a version expired error
+ *
+ * @example
+ * ```typescript
+ * mockLambderVersionExpired('user.updateProfile')
+ * ```
+ */
+export function mockLambderVersionExpired(apiName, options) {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+    return (async ({ request }) => {
+        await ensureMSW();
+        const body = (await request.json());
+        if (body.apiName !== apiName) {
+            return;
+        }
+        console.log(`[MSW Lambder] Mocking version expired for ${apiName}`);
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload: null,
+            versionExpired: true,
+            errorMessage: 'Version expired',
+        });
+    });
+}
+/**
+ * Helper function to create the MSW http.post handler with proper path matching
+ * This is useful when you need to set up multiple handlers with the same path
+ *
+ * @example
+ * ```typescript
+ * import { setupServer } from 'msw/node';
+ *
+ * const server = setupServer(
+ *   createLambderApiHandler('/api', [
+ *     mockLambderApi('user.getProfile', () => ({ name: 'Test User' })),
+ *     mockLambderApi('user.updateProfile', (input) => ({ success: true }))
+ *   ])
+ * );
+ * ```
+ */
+export function createLambderApiHandler(apiPath, handlers) {
+    return (async (info) => {
+        await ensureMSW();
+        // Call each handler in sequence until one handles the request
+        for (const handler of handlers) {
+            const result = await handler(info);
+            if (result) {
+                return result;
+            }
+        }
+        // No handler matched
+        return;
+    });
+}

package/dist/LambderResolver.d.ts

@@ -1,25 +1,26 @@
 import type { LambderRenderContext } from "./Lambder.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
+import type { ApiContractShape, ApiOutput } from "./LambderApiContract.js";
 type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
-interface DieResolverMethods {
-    raw: MethodType<LambderResponseBuilder, 'raw'>;
-    json: MethodType<LambderResponseBuilder, 'json'>;
-    xml: MethodType<LambderResponseBuilder, 'xml'>;
-    html: MethodType<LambderResponseBuilder, 'html'>;
-    status301: MethodType<LambderResponseBuilder, 'status301'>;
-    status404: MethodType<LambderResponseBuilder, 'status404'>;
-    cors: MethodType<LambderResponseBuilder, 'cors'>;
-    fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
-    file: MethodType<LambderResponseBuilder, 'file'>;
-    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
-    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
-    api: MethodType<LambderResponseBuilder, 'api'>;
+interface DieResolverMethods<TContract extends ApiContractShape, TApiName extends keyof TContract & string> {
+    raw: MethodType<LambderResponseBuilder<TContract>, 'raw'>;
+    json: MethodType<LambderResponseBuilder<TContract>, 'json'>;
+    xml: MethodType<LambderResponseBuilder<TContract>, 'xml'>;
+    html: MethodType<LambderResponseBuilder<TContract>, 'html'>;
+    status301: MethodType<LambderResponseBuilder<TContract>, 'status301'>;
+    status404: MethodType<LambderResponseBuilder<TContract>, 'status404'>;
+    cors: MethodType<LambderResponseBuilder<TContract>, 'cors'>;
+    fileBase64: MethodType<LambderResponseBuilder<TContract>, 'fileBase64'>;
+    file: MethodType<LambderResponseBuilder<TContract>, 'file'>;
+    ejsFile: MethodType<LambderResponseBuilder<TContract>, 'ejsFile'>;
+    ejsTemplate: MethodType<LambderResponseBuilder<TContract>, 'ejsTemplate'>;
+    api: (payload: ApiOutput<TContract, TApiName> | null, config?: Parameters<LambderResponseBuilder<TContract>['api']>[1], headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]) => LambderResolverResponse;
 }
-export default class LambderResolver extends LambderResponseBuilder {
+export default class LambderResolver<TContract extends ApiContractShape = any, TApiName extends keyof TContract & string = any> extends LambderResponseBuilder<TContract> {
     resolve: (response: LambderResolverResponse) => void;
     reject: (err: Error) => void;
-    die: DieResolverMethods;
+    die: DieResolverMethods<TContract, TApiName>;
     constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: {
         isCorsEnabled: boolean;
         publicPath: string;
@@ -29,6 +30,7 @@ export default class LambderResolver extends LambderResponseBuilder {
         resolve: (response: LambderResolverResponse) => void;
         reject: (err: Error) => void;
     });
+    api(payload: ApiOutput<TContract, TApiName> | null, config?: Parameters<LambderResponseBuilder<TContract>['api']>[1], headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]): LambderResolverResponse;
     private autoResolve;
     private autoResolvePromise;
 }

package/dist/LambderResolver.js

@@ -22,6 +22,10 @@ export default class LambderResolver extends LambderResponseBuilder {
             api: this.autoResolve(this.api),
         };
     }
+    // Override api method with proper typing
+    api(payload, config, headers) {
+        return super.api(payload, config, headers);
+    }
     autoResolve(method) {
         return (...args) => {
             const result = method.apply(this, args);

package/dist/LambderResponseBuilder.d.ts

@@ -1,5 +1,6 @@
 import LambderUtils from "./LambderUtils.js";
 import { LambderRenderContext } from "./Lambder.js";
+import type { ApiContractShape } from "./LambderApiContract.js";
 export type LambderResolverResponse = {
     statusCode: number;
     multiValueHeaders?: Record<string, string[]>;
@@ -17,7 +18,7 @@ export type LambderApiResponseConfig = {
 export type LambderApiResponse<T> = LambderApiResponseConfig & {
     payload?: T | null;
 };
-export default class LambderResponseBuilder {
+export default class LambderResponseBuilder<TContract extends ApiContractShape = any> {
     private isCorsEnabled;
     private publicPath;
     private apiVersion;

package/dist/LambderSessionController.d.ts

@@ -14,6 +14,7 @@ export default class LambderSessionController {
     });
     private areRequestSessionTokensValid;
     createSession(sessionKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext>;
+    regenerateSession(): Promise<LambderSessionContext>;
     fetchSession(): Promise<LambderSessionContext>;
     fetchSessionIfExists(): Promise<LambderSessionContext | null>;
     isSessionValid(session: any): boolean;

package/dist/LambderSessionController.js

@@ -31,6 +31,16 @@ export default class LambderSessionController {
         return this.ctx.session;
     }
     ;
+    async regenerateSession() {
+        if (!this.ctx.session)
+            throw new Error("Session not found.");
+        const newSession = await this.lambderSessionManager.regenerateSession(this.ctx.session);
+        this.ctx._otherInternal.addHeaderFnAccumulator.push({ key: "Set-Cookie", value: `${this.sessionTokenCookieKey}=${newSession.sessionToken}; Expires=${new Date(newSession.expiresAt * 1000).toUTCString()}; Path=/; HttpOnly; SameSite=Lax; Secure` });
+        this.ctx._otherInternal.addHeaderFnAccumulator.push({ key: "Set-Cookie", value: `${this.sessionCsrfCookieKey}=${newSession.csrfToken}; Expires=${new Date(newSession.expiresAt * 1000).toUTCString()}; Path=/; SameSite=Lax; Secure` });
+        this.ctx.session = newSession;
+        return this.ctx.session;
+    }
+    ;
     async fetchSession() {
         if (!this.areRequestSessionTokensValid()) {
             throw new Error("Session tokens are invalid");

package/dist/LambderSessionManager.d.ts

@@ -6,6 +6,7 @@ export type LambderSessionContext = {
     data: any;
     createdAt: number;
     expiresAt: number;
+    lastAccessedAt: number;
     ttlInSeconds: number;
 };
 export default class LambderSessionManager {
@@ -14,14 +15,17 @@ export default class LambderSessionManager {
     private partitionKey;
     private sortKey;
     private ddbDocumentClient;
-    constructor({ tableName, tableRegion, partitionKey, sortKey, sessionSalt, }: {
+    private enableSlidingExpiration;
+    constructor({ tableName, tableRegion, partitionKey, sortKey, sessionSalt, enableSlidingExpiration, }: {
         tableName: string;
         tableRegion: string;
         partitionKey: string;
         sortKey: string;
         sessionSalt: string;
+        enableSlidingExpiration?: boolean;
     });
     private sessionUserKeyHasher;
+    private constantTimeCompare;
     private ddbGetItem;
     private ddbPutItem;
     private ddbDeleteItem;
@@ -33,4 +37,5 @@ export default class LambderSessionManager {
     isSessionValid(session: any, sessionToken: any, csrfToken: any, skipCsrfTokenCheck?: boolean): boolean;
     deleteSession(session: Record<string, any>): Promise<boolean>;
     deleteSessionAll(session: Record<string, any>): Promise<boolean>;
+    regenerateSession(session: LambderSessionContext): Promise<LambderSessionContext>;
 }