lambder 2.0.18 → 3.0.0

package/examples/msw-testing-example.ts

@@ -1,280 +0,0 @@
-/**
- * LambderMSW Testing Example
- * 
- * This example shows how to use LambderMSW with MSW (Mock Service Worker)
- * to test your Lambder APIs with full type safety.
- * 
- * To run this example:
- * 1. Install MSW: npm install msw --save-dev
- * 2. Install a test runner: npm install vitest --save-dev
- * 3. Create this file in your test directory
- * 
- * NOTE: This is an example file. Type errors are expected since dependencies
- * may not be installed in the examples directory. Copy this to your project's
- * test directory to use it.
- */
-
-// @ts-nocheck - Example file, types may not be available
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { setupServer } from 'msw/node';
-import { z } from 'zod';
-import { LambderMSW, LambderCaller } from '../src/index.ts';
-import Lambder from '../src/Lambder.js';
-
-// Define your API contract using Lambder chaining
-const lambder = new Lambder({ publicPath: './public' })
-    .addApi('getUserById', {
-        input: z.object({ userId: z.string() }),
-        output: z.object({ id: z.string(), name: z.string(), email: z.string() }).nullable()
-    }, async () => ({} as any)) // Dummy handler for type inference
-    .addApi('createUser', {
-        input: z.object({ name: z.string(), email: z.string() }),
-        output: z.object({ id: z.string(), name: z.string(), email: z.string() })
-    }, async () => ({} as any))
-    .addApi('getUsers', {
-        input: z.object({ limit: z.number().optional() }),
-        output: z.array(z.object({ id: z.string(), name: z.string(), email: z.string() }))
-    }, async () => ({} as any))
-    .addApi('deleteUser', {
-        input: z.object({ userId: z.string() }),
-        output: z.object({ success: z.boolean() })
-    }, async () => ({} as any));
-
-type ApiContractType = typeof lambder.ApiContract;
-
-// Setup LambderMSW with type safety
-const lambderMSW = new LambderMSW<ApiContractType>({
-    apiPath: '/secure',
-    apiVersion: '1.0.0',
-});
-
-// Create mock handlers
-const handlers = [
-    // Mock getUserById - returns user or null
-    lambderMSW.mockApi('getUserById', async (payload) => {
-        const users: Record<string, { id: string; name: string; email: string }> = {
-            '1': { id: '1', name: 'John Doe', email: 'john@example.com' },
-            '2': { id: '2', name: 'Jane Smith', email: 'jane@example.com' },
-        };
-        
-        return users[payload?.userId || ''] || null;
-    }),
-
-    // Mock createUser - simulates creating a user
-    lambderMSW.mockApi('createUser', async (payload) => {
-        return {
-            id: Math.random().toString(36).substring(7),
-            name: payload?.name || '',
-            email: payload?.email || '',
-        };
-    }, { 
-        delay: 100, // Simulate 100ms network delay
-        message: 'User created successfully'
-    }),
-
-    // Mock getUsers - returns a list of users
-    lambderMSW.mockApi('getUsers', async (payload) => {
-        const allUsers = [
-            { id: '1', name: 'John Doe', email: 'john@example.com' },
-            { id: '2', name: 'Jane Smith', email: 'jane@example.com' },
-            { id: '3', name: 'Bob Johnson', email: 'bob@example.com' },
-        ];
-        
-        const limit = payload?.limit || 10;
-        return allUsers.slice(0, limit);
-    }),
-
-    // Mock deleteUser - simulate authorization error
-    lambderMSW.mockNotAuthorized('deleteUser'),
-];
-
-// Setup MSW server
-const server = setupServer(...handlers);
-
-// Setup LambderCaller
-const lambderCaller = new LambderCaller<ApiContractType>({
-    apiPath: '/secure',
-    isCorsEnabled: false,
-});
-
-// Test suite
-describe('LambderMSW Testing Example', () => {
-    beforeAll(() => {
-        server.listen({ onUnhandledRequest: 'error' });
-    });
-
-    afterEach(() => {
-        server.resetHandlers();
-    });
-
-    afterAll(() => {
-        server.close();
-    });
-
-    it('should fetch user by id', async () => {
-        const user = await lambderCaller.api('getUserById', { userId: '1' });
-        
-        expect(user).toEqual({
-            id: '1',
-            name: 'John Doe',
-            email: 'john@example.com',
-        });
-    });
-
-    it('should return null for non-existent user', async () => {
-        const user = await lambderCaller.api('getUserById', { userId: '999' });
-        
-        expect(user).toBeNull();
-    });
-
-    it('should create a new user with delay', async () => {
-        const startTime = Date.now();
-        
-        const newUser = await lambderCaller.api('createUser', {
-            name: 'Alice Wonder',
-            email: 'alice@example.com',
-        });
-        
-        const endTime = Date.now();
-        
-        expect(newUser?.name).toBe('Alice Wonder');
-        expect(newUser?.email).toBe('alice@example.com');
-        expect(newUser?.id).toBeDefined();
-        
-        // Check that delay was applied (at least 100ms)
-        expect(endTime - startTime).toBeGreaterThanOrEqual(100);
-    });
-
-    it('should fetch list of users', async () => {
-        const users = await lambderCaller.api('getUsers', { limit: 2 });
-        
-        expect(users).toHaveLength(2);
-        expect(users?.[0]?.name).toBe('John Doe');
-        expect(users?.[1]?.name).toBe('Jane Smith');
-    });
-
-    it('should handle authorization error', async () => {
-        let errorCaught = false;
-        
-        try {
-            await lambderCaller.api('deleteUser', { userId: '1' });
-        } catch (error: any) {
-            errorCaught = true;
-            expect(error.notAuthorized).toBe(true);
-        }
-        
-        expect(errorCaught).toBe(true);
-    });
-
-    it('should override handler for specific test', async () => {
-        // Override the getUserById handler for this test only
-        server.use(
-            lambderMSW.mockApi('getUserById', async (payload) => {
-                return {
-                    id: payload?.userId || '',
-                    name: 'Override User',
-                    email: 'override@example.com',
-                };
-            })
-        );
-
-        const user = await lambderCaller.api('getUserById', { userId: '999' });
-        
-        expect(user?.name).toBe('Override User');
-    });
-
-    it('should simulate session expired', async () => {
-        // Add a handler that simulates session expiration
-        server.use(
-            lambderMSW.mockSessionExpired('getUserById')
-        );
-
-        let errorCaught = false;
-        
-        try {
-            await lambderCaller.api('getUserById', { userId: '1' });
-        } catch (error: any) {
-            errorCaught = true;
-            expect(error.sessionExpired).toBe(true);
-        }
-        
-        expect(errorCaught).toBe(true);
-    });
-
-    it('should simulate custom error', async () => {
-        server.use(
-            lambderMSW.mockError('createUser', 'Email already exists')
-        );
-
-        let errorCaught = false;
-        
-        try {
-            await lambderCaller.api('createUser', {
-                name: 'Duplicate',
-                email: 'john@example.com',
-            });
-        } catch (error: any) {
-            errorCaught = true;
-            expect(error.errorMessage).toBe('Email already exists');
-        }
-        
-        expect(errorCaught).toBe(true);
-    });
-});
-
-// Example: Testing with dynamic responses
-describe('Dynamic Response Testing', () => {
-    beforeAll(() => server.listen());
-    afterEach(() => server.resetHandlers());
-    afterAll(() => server.close());
-
-    it('should handle different query parameters', async () => {
-        server.use(
-            lambderMSW.mockApi('getUsers', async (payload) => {
-                const limit = payload?.limit || 10;
-                
-                // Generate mock users based on limit
-                return Array.from({ length: limit }, (_, i) => ({
-                    id: `${i + 1}`,
-                    name: `User ${i + 1}`,
-                    email: `user${i + 1}@example.com`,
-                }));
-            })
-        );
-
-        const users3 = await lambderCaller.api('getUsers', { limit: 3 });
-        expect(users3).toHaveLength(3);
-
-        const users5 = await lambderCaller.api('getUsers', { limit: 5 });
-        expect(users5).toHaveLength(5);
-    });
-});
-
-// Example: Testing error conditions
-describe('Error Handling', () => {
-    beforeAll(() => server.listen());
-    afterEach(() => server.resetHandlers());
-    afterAll(() => server.close());
-
-    it('should handle handler throwing error', async () => {
-        server.use(
-            lambderMSW.mockApi('getUserById', async () => {
-                throw new Error('Database connection failed');
-            })
-        );
-
-        let errorCaught = false;
-        
-        try {
-            await lambderCaller.api('getUserById', { userId: '1' });
-        } catch (error: any) {
-            errorCaught = true;
-            expect(error.errorMessage).toBe('Database connection failed');
-        }
-        
-        expect(errorCaught).toBe(true);
-    });
-});
-
-console.log('✅ LambderMSW example tests configured!');
-console.log('📖 See docs/LAMBDER_MSW.md for more information');

package/examples/secure-session-example.ts

@@ -1,207 +0,0 @@
-import { z } from "zod";
-import Lambder from "../src/Lambder.js";
-
-// Example: Secure session handling with all security fixes applied
-
-const lambder = new Lambder({
-    publicPath: "/public",
-    apiPath: "/api",
-    ejsPath: "/views",
-})
-// Enable session management with sliding expiration
-.enableDdbSession(
-    {
-        tableName: process.env.SESSION_TABLE || "sessions",
-        tableRegion: process.env.AWS_REGION || "us-east-1",
-        sessionSalt: process.env.SESSION_SALT || "change-this-to-a-secure-random-string",
-        enableSlidingExpiration: true, // Sessions extend on each access
-    },
-    { partitionKey: "pk", sortKey: "sk" }
-)
-// Example: Login API with session regeneration
-.addApi("user.login", {
-    input: z.object({ username: z.string(), password: z.string() }),
-    output: z.object({ success: z.boolean(), csrfToken: z.string().optional(), error: z.string().optional() })
-}, async (ctx, resolver) => {
-    const { username, password } = ctx.apiPayload;
-
-    // Validate credentials (implement your own logic)
-    const user = await authenticateUser(username, password);
-    if (!user) {
-        return resolver.api({ success: false, error: "Invalid credentials" });
-    }
-
-    // Create new session
-    const sessionController = lambder.getSessionController(ctx);
-    const session = await sessionController.createSession(user.id, {
-        userId: user.id,
-        username: user.username,
-        role: user.role,
-    });
-
-    return resolver.api({
-        success: true,
-        csrfToken: session.csrfToken,
-    });
-})
-// Example: Protected API that requires session
-.addSessionApi("user.profile", {
-    input: z.void(),
-    output: z.object({ userId: z.string(), username: z.string(), role: z.string() })
-}, async (ctx, resolver) => {
-    // Session is automatically fetched and validated
-    const sessionData = ctx.session.data;
-
-    return resolver.api({
-        userId: sessionData.userId,
-        username: sessionData.username,
-        role: sessionData.role,
-    });
-})
-// Example: Sensitive operation that regenerates session
-.addSessionApi("user.changePassword", {
-    input: z.object({ oldPassword: z.string(), newPassword: z.string() }),
-    output: z.object({ success: z.boolean(), message: z.string().optional(), csrfToken: z.string().optional(), error: z.string().optional() })
-}, async (ctx, resolver) => {
-    const { oldPassword, newPassword } = ctx.apiPayload;
-    const sessionController = lambder.getSessionController(ctx);
-
-    // Validate old password
-    const isValid = await validatePassword(
-        ctx.session.data.userId,
-        oldPassword
-    );
-    if (!isValid) {
-        return resolver.api({ success: false, error: "Invalid password" });
-    }
-
-    // Update password
-    await updatePassword(ctx.session.data.userId, newPassword);
-
-    // IMPORTANT: Regenerate session after password change to prevent session fixation
-    const newSession = await sessionController.regenerateSession();
-
-    // OPTIONAL: End all other sessions for this user
-    await sessionController.endSessionAll();
-
-    return resolver.api({
-        success: true,
-        message: "Password changed successfully",
-        csrfToken: newSession.csrfToken, // Send new CSRF token
-    });
-})
-// Example: Update session data
-.addSessionApi("user.updatePreferences", {
-    input: z.object({ theme: z.string(), language: z.string() }),
-    output: z.object({ success: z.boolean(), message: z.string() })
-}, async (ctx, resolver) => {
-    const { theme, language } = ctx.apiPayload;
-    const sessionController = lambder.getSessionController(ctx);
-
-    // Update session data (also extends expiration if sliding is enabled)
-    await sessionController.updateSessionData({
-        ...ctx.session.data,
-        preferences: { theme, language },
-    });
-
-    return resolver.api({
-        success: true,
-        message: "Preferences updated",
-    });
-})
-// Example: Logout
-.addSessionApi("user.logout", {
-    input: z.void(),
-    output: z.object({ success: z.boolean(), message: z.string() })
-}, async (ctx, resolver) => {
-    const sessionController = lambder.getSessionController(ctx);
-
-    // End current session
-    await sessionController.endSession();
-
-    return resolver.api({
-        success: true,
-        message: "Logged out successfully",
-    });
-})
-// Example: Logout from all devices
-.addSessionApi("user.logoutAll", {
-    input: z.void(),
-    output: z.object({ success: z.boolean(), message: z.string() })
-}, async (ctx, resolver) => {
-    const sessionController = lambder.getSessionController(ctx);
-
-    // End all sessions for this user (same sessionKey)
-    await sessionController.endSessionAll();
-
-    return resolver.api({
-        success: true,
-        message: "Logged out from all devices",
-    });
-})
-// Example: Optional session (check if logged in)
-.addApi("user.checkAuth", {
-    input: z.object({}),
-    output: z.object({
-        authenticated: z.boolean(),
-        userId: z.string().optional(),
-        username: z.string().optional(),
-    })
-}, async (ctx, resolver) => {
-    const sessionController = lambder.getSessionController(ctx);
-
-    // Try to fetch session without throwing error
-    const session = await sessionController.fetchSessionIfExists();
-
-    if (session) {
-        return resolver.api({
-            authenticated: true,
-            userId: session.data.userId,
-            username: session.data.username,
-        });
-    } else {
-        return resolver.api({
-            authenticated: false,
-        });
-    }
-})
-// Example: Route with session
-.addSessionRoute("/dashboard", async (ctx, resolver) => {
-    // Session is automatically fetched and validated
-    const userData = ctx.session.data;
-
-    return resolver.ejsFile("dashboard.ejs", {
-        user: userData,
-        csrfToken: ctx.session.csrfToken,
-    });
-})
-// Example: Route with optional session
-.addRoute("/", async (ctx, resolver) => {
-    const sessionController = lambder.getSessionController(ctx);
-    const session = await sessionController.fetchSessionIfExists();
-
-    return resolver.ejsFile("home.ejs", {
-        isLoggedIn: !!session,
-        user: session?.data,
-        csrfToken: session?.csrfToken,
-    });
-});
-
-// Dummy functions (implement these)
-async function authenticateUser(username: string, password: string) {
-    // Implement your authentication logic
-    return { id: "user123", username, role: "user" };
-}
-
-async function validatePassword(userId: string, password: string) {
-    // Implement password validation
-    return true;
-}
-
-async function updatePassword(userId: string, newPassword: string) {
-    // Implement password update
-}
-
-export const handler = async (event: any, context: any) => {
-    return await lambder.render(event, context);
-};

package/examples/zod-chained-api-example.ts

@@ -1,63 +0,0 @@
-import { z } from "zod";
-import Lambder from "../src/index.js";
-
-// 1. Define reusable schemas
-const UserSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    email: z.string().email(),
-});
-
-const CreateUserSchema = z.object({
-    name: z.string(),
-    email: z.string().email(),
-});
-
-// 2. Initialize Lambder and chain APIs
-const lambder = new Lambder({ 
-    publicPath: "./public",
-    apiPath: "/api" 
-})
-    .addApi("getUser", {
-        input: z.object({ userId: z.string() }),
-        output: UserSchema
-    }, async (ctx, resolver) => {
-        // ctx.apiPayload is typed as { userId: string }
-        const { userId } = ctx.apiPayload;
-        
-        return resolver.api({
-            id: userId,
-            name: "John Doe",
-            email: "john@example.com"
-        });
-    })
-    .addApi("createUser", {
-        input: CreateUserSchema,
-        output: UserSchema
-    }, async (ctx, resolver) => {
-        // ctx.apiPayload is typed as { name: string, email: string }
-        const { name, email } = ctx.apiPayload;
-        
-        return resolver.api({
-            id: "123",
-            name,
-            email
-        });
-    });
-
-// 3. Export the inferred contract type for frontend use
-export type ApiContractType = typeof lambder.ApiContract;
-
-// 4. Modular example using .use()
-const authApi = <T>(l: Lambder<T>) => {
-    return l.addApi("login", {
-        input: z.object({ username: z.string(), password: z.string() }),
-        output: z.object({ token: z.string() })
-    }, async (ctx, resolver) => {
-        return resolver.api({ token: "abc-123" });
-    });
-};
-
-const lambderWithAuth = lambder.use(authApi);
-
-export type AuthContract = typeof lambderWithAuth.ApiContract;