lambder 1.0.128 → 1.0.130

package/examples/test-output-type-enforcement.ts

@@ -0,0 +1,101 @@
+/**
+ * Test file to verify output type enforcement
+ * This file should have TypeScript errors if output types are not correct
+ */
+
+import Lambder from '../src/Lambder.js';
+import type { ApiContract } from '../src/index.js';
+
+// Define a simple API contract
+type TestContract = ApiContract<{
+    getNumber: { input: void, output: number },
+    getString: { input: { id: string }, output: string },
+    getUser: { input: { userId: string }, output: { id: string; name: string; age: number } },
+}>;
+
+const lambder = new Lambder<TestContract>({
+    publicPath: './public',
+    apiPath: '/api',
+});
+
+// ✅ CORRECT: Returns the right type
+lambder.addApi('getNumber', async (ctx, resolver) => {
+    // This should work - returning number
+    return resolver.api(42);
+});
+
+// ❌ INCORRECT: Should cause TypeScript error - returning wrong type
+lambder.addApi('getNumber', async (ctx, resolver) => {
+    // @ts-expect-error - Testing type enforcement: should not accept string when output is number
+    return resolver.api("wrong type");
+});
+
+// ✅ CORRECT: Returns string
+lambder.addApi('getString', async (ctx, resolver) => {
+    const id = ctx.apiPayload.id;
+    return resolver.api(`String for ${id}`);
+});
+
+// ❌ INCORRECT: Should cause TypeScript error - returning wrong type
+lambder.addApi('getString', async (ctx, resolver) => {
+    // @ts-expect-error - Testing type enforcement: should not accept number when output is string
+    return resolver.api(123);
+});
+
+// ✅ CORRECT: Returns correct object shape
+lambder.addApi('getUser', async (ctx, resolver) => {
+    return resolver.api({
+        id: ctx.apiPayload.userId,
+        name: "John Doe",
+        age: 30,
+    });
+});
+
+// ❌ INCORRECT: Should cause TypeScript error - missing required field
+lambder.addApi('getUser', async (ctx, resolver) => {
+    // @ts-expect-error - Testing type enforcement: missing 'age' field
+    return resolver.api({
+        id: ctx.apiPayload.userId,
+        name: "John Doe",
+        // age is missing
+    });
+});
+
+// ❌ INCORRECT: Should cause TypeScript error - wrong field type
+lambder.addApi('getUser', async (ctx, resolver) => {
+    return resolver.api({
+        id: ctx.apiPayload.userId,
+        name: "John Doe",
+        // @ts-expect-error - Testing type enforcement: age should be number, not string
+        age: "30", // wrong type
+    });
+});
+
+// ✅ CORRECT: Using null is allowed
+lambder.addApi('getNumber', async (ctx, resolver) => {
+    return resolver.api(null);
+});
+
+// ✅ CORRECT: Using resolver.die.api also enforces types
+lambder.addApi('getNumber', async (ctx, resolver) => {
+    return resolver.die.api(42);
+});
+
+// ❌ INCORRECT: resolver.die.api should also enforce types
+lambder.addApi('getNumber', async (ctx, resolver) => {
+    // @ts-expect-error - Testing type enforcement: die.api should also check types
+    return resolver.die.api("wrong type");
+});
+
+// Test with addSessionApi
+lambder.addSessionApi('getString', async (ctx, resolver) => {
+    // Should also enforce output type for session APIs
+    return resolver.api("correct string");
+});
+
+lambder.addSessionApi('getString', async (ctx, resolver) => {
+    // @ts-expect-error - Testing type enforcement: session API should also enforce types
+    return resolver.api(123);
+});
+
+console.log("If this file compiles with @ts-expect-error comments, output type enforcement is working!");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.128",
+  "version": "1.0.130",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,6 +27,14 @@
     "path-to-regexp": "^6.2.1",
     "querystring": "^0.2.1"
   },
+  "peerDependencies": {
+    "msw": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "msw": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.136",
     "@types/cookie": "^0.6.0",

package/src/Lambder.ts

@@ -140,11 +140,11 @@ export default class Lambder<TContract extends ApiContractShape = any> {
     }
 
     enableDdbSession(
-        { tableName, tableRegion, sessionSalt }: { tableName: string; tableRegion: string; sessionSalt: string; }, 
+        { tableName, tableRegion, sessionSalt, enableSlidingExpiration }: { tableName: string; tableRegion: string; sessionSalt: string; enableSlidingExpiration?: boolean; }, 
         { partitionKey, sortKey }: { partitionKey: string, sortKey: string } = { partitionKey: "pk", sortKey: "sk" }
     ){
         this.lambderSessionManager = new LambderSessionManager({
-            tableName, tableRegion, partitionKey, sortKey, sessionSalt
+            tableName, tableRegion, partitionKey, sortKey, sessionSalt, enableSlidingExpiration
         });
     }
 
@@ -249,7 +249,7 @@ export default class Lambder<TContract extends ApiContractShape = any> {
         apiName: TApiName,
         actionFn: (
             ctx: LambderRenderContext<TContract[TApiName]['input']>,
-            resolver: LambderResolver
+            resolver: LambderResolver<TContract, TApiName>
         ) => LambderResolverResponse|Promise<LambderResolverResponse>
     ):void;
     // Overload for untyped API with string (backward compatibility, must be last)
@@ -281,7 +281,7 @@ export default class Lambder<TContract extends ApiContractShape = any> {
         apiName: TApiName,
         actionFn: (
             ctx: LambderRenderContext<TContract[TApiName]['input']>,
-            resolver: LambderResolver
+            resolver: LambderResolver<TContract, TApiName>
         ) => LambderResolverResponse|Promise<LambderResolverResponse>
     ):void;
     // Overload for untyped session API with string (backward compatibility, must be last)

package/src/LambderMSW.ts

@@ -0,0 +1,330 @@
+import type { ApiContractShape } from './LambderApiContract.js';
+
+// Type for MSW HttpHandler (defined locally to avoid hard dependency on msw types)
+export type HttpHandler = (info: any) => Promise<Response | undefined> | Response | undefined;
+
+// Dynamic imports to avoid requiring MSW as a hard dependency
+let http: any;
+let HttpResponse: any;
+
+/**
+ * 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<
+    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 {
+    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 }: any) => {
+        await ensureMSW();
+
+        const body = (await request.json()) as {
+            apiName: string;
+            payload?: TContract[TApiName]['input'];
+            version?: string;
+            token?: string;
+            siteHost?: string;
+        };
+
+        // 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 as TContract[TApiName]['input']);
+
+        // Return in Lambder API response format
+        return HttpResponse.json({
+            ...(apiVersion !== null ? { apiVersion } : {}),
+            payload,
+        });
+    }) as any;
+}
+
+/**
+ * Creates a mock handler that returns an error for a Lambder API endpoint
+ * 
+ * @example
+ * ```typescript
+ * mockLambderApiError('user.deleteAccount', 'Account deletion failed')
+ * ```
+ */
+export 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 {
+    const apiPath = options?.apiPath ?? '/api';
+    const delay = options?.delay ?? 0;
+    const apiVersion = options?.apiVersion ?? null;
+
+    return (async ({ request }: any) => {
+        await ensureMSW();
+
+        const body = (await request.json()) as { 
+            apiName: string; 
+            payload?: any;
+        };
+
+        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,
+        });
+    }) as any;
+}
+
+/**
+ * Creates a mock handler that simulates a session expired error
+ * 
+ * @example
+ * ```typescript
+ * mockLambderSessionExpired('user.updateProfile')
+ * ```
+ */
+export 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 {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+
+    return (async ({ request }: any) => {
+        await ensureMSW();
+
+        const body = (await request.json()) as { 
+            apiName: string; 
+            payload?: any;
+        };
+
+        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',
+        });
+    }) as any;
+}
+
+/**
+ * Creates a mock handler that simulates a "not authorized" error
+ * 
+ * @example
+ * ```typescript
+ * mockLambderNotAuthorized('admin.deleteUser')
+ * ```
+ */
+export 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 {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+
+    return (async ({ request }: any) => {
+        await ensureMSW();
+
+        const body = (await request.json()) as { 
+            apiName: string; 
+            payload?: any;
+        };
+
+        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',
+        });
+    }) as any;
+}
+
+/**
+ * Creates a mock handler that simulates a version expired error
+ * 
+ * @example
+ * ```typescript
+ * mockLambderVersionExpired('user.updateProfile')
+ * ```
+ */
+export 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 {
+    const apiPath = options?.apiPath ?? '/api';
+    const apiVersion = options?.apiVersion ?? null;
+
+    return (async ({ request }: any) => {
+        await ensureMSW();
+
+        const body = (await request.json()) as { 
+            apiName: string; 
+            payload?: any;
+        };
+
+        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',
+        });
+    }) as any;
+}
+
+/**
+ * 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: string,
+    handlers: HttpHandler[]
+): HttpHandler {
+    return (async (info: any) => {
+        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;
+    }) as any;
+}

package/src/LambderResolver.ts

@@ -1,28 +1,36 @@
 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> {
     public resolve: (response: LambderResolverResponse) => void;
     public reject: (err: Error) => void;
-    public die: DieResolverMethods;
+    public die: DieResolverMethods<TContract, TApiName>;
 
     constructor(
         { isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: 
@@ -56,6 +64,15 @@ export default class LambderResolver extends LambderResponseBuilder {
         };
     }
 
+    // Override api method with proper typing
+    api(
+        payload: ApiOutput<TContract, TApiName> | null,
+        config?: Parameters<LambderResponseBuilder<TContract>['api']>[1],
+        headers?: Parameters<LambderResponseBuilder<TContract>['api']>[2]
+    ): LambderResolverResponse {
+        return super.api(payload, config, headers);
+    }
+
     private autoResolve<
         T extends (...args: any[]) => LambderResolverResponse
     >(method: T): (...funcArgs: Parameters<T>) => LambderResolverResponse {

package/src/LambderResponseBuilder.ts

@@ -4,6 +4,7 @@ import ejs from "ejs";
 import mimeTypeResolver from "mime-types";
 import LambderUtils from "./LambderUtils.js";
 import { LambderRenderContext } from "./Lambder.js";
+import type { ApiContractShape } from "./LambderApiContract.js";
 
 const convertToMultiHeader = (
     headers: Record<string, string|string[]> | undefined
@@ -38,7 +39,7 @@ export type LambderApiResponse<T> = LambderApiResponseConfig & {
     payload?: T | null; 
 }
 
-export default class LambderResponseBuilder {
+export default class LambderResponseBuilder<TContract extends ApiContractShape = any> {
     private isCorsEnabled: boolean;
     private publicPath: string;
     private apiVersion: string|null;

package/src/LambderSessionController.ts

@@ -48,6 +48,15 @@ export default class LambderSessionController {
         return this.ctx.session;
     };
 
+    async regenerateSession (): Promise<LambderSessionContext> {
+        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 (): Promise<LambderSessionContext>{
         if(!this.areRequestSessionTokensValid()){ throw new Error("Session tokens are invalid"); }