lambder 1.0.114 → 1.0.116

package/Readme.md

@@ -55,7 +55,7 @@ lambder.addApi("getCompanyPage", async ({ apiPayload }, res) => {
 // Start a session from an API
 lambder.addApi("loginUser", async (ctx, res) => {
     const user = await fetchUserData();
-    await lambder.getSessionController(ctx).startSession(user.id);
+    await lambder.getSessionController(ctx).createSession(user.id);
     return res.api({ success: true });
 });
 
@@ -218,25 +218,81 @@ lambder.addModule(async (lambder: Lambder): Promise<void> => {
 
 ### Session Management
 
+You can enable session tracking by:
+
 ```typescript
-lambder.addApi("getCompanyPage", async (ctx, res) => {
+// Enable session
+lambder.enableDdbSession({
+    tableName: "website-session",
+    tableRegion: "us-east-1",
+    sessionSalt: "8p6Vt+4b1w3N8d/dcJ47QF3DRkp9koFg0G" // Change salt
+});
+```
+
+After you enable the session, you can access to the session controller:
+
+```typescript
+    // Create session controller:
     const sessionController = lambder.getSessionController(ctx);
+
+    /*
+    sessionController: {
+        async createSession(sessionKey, data, ttlInSeconds): 
+        // Starts a new session and persists the session data to DDB.
+
+        async fetchSession(): 
+        // Fetch and validate if there is an existing session
+        // This is automatically done for addSessionRoute and addSessionApi
+        // Throws if session not found
+
+        async fetchSessionIfExists(): 
+        // Runs fetchSession and returns the session if found. Otherwise return null
+
+        async updateSessionData(updatedData): 
+        // Updates the active sessions data and persist it to ddb.
+
+        async endSession(): Start a new session
+        // End session and delete from DDB.
+
+        async endSessionAll(): Start a new session
+        // Ends and deletes all registered sessions for this sessionKey across all devices
+    }
+    */
+```
+
+
+
+#### Session Examples
+```typescript
+lambder.addApi("getCompanyPage", async (ctx, res) => {
+    
+    // createSession: Start a new session
     const userId = "37234";
-    await sessionController.startSession(userId, { "business": "Session data goes here"  });
-    console.log(ctx.session?.userKey); // "37234"
+    await lambder.getSessionController(ctx)
+        .createSession(userId, { "business": "Session data goes here"  });
+    console.log(ctx.session?.sessionKey); // "37234"
     console.log(ctx.session?.data?.business); // "Session data goes here"
 
-    await sessionController.updateSessionData({ "business2": "Session data updated"  });
-    console.log(ctx.session?.userKey); // "37234"
+    // fetchSession: Fetch and validate if there is an existing session
+    // This is automatically done for addSessionRoute and addSessionApi
+    await lambder.getSessionController(ctx).fetchSession();
+    console.log(ctx.session?.sessionKey); // "37234"
+    
+    // updateSessionData: Updates the active sessions data and persist it to ddb.
+    await lambder.getSessionController(ctx)
+        .updateSessionData({ "business2": "Session data updated"  });
+    console.log(ctx.session?.sessionKey); // "37234"
     console.log(ctx.session?.data?.business); // undefined
     console.log(ctx.session?.data?.business2); // "Session data updated"
     
-    await sessionController.deleteSession(); // End session
-    console.log(ctx.session?.userKey); // undefined
+    // endSession: Ends the session and removes it from ddb
+    await lambder.getSessionController(ctx).endSession(); // End session
+    console.log(ctx.session?.sessionKey); // undefined
     console.log(ctx.session?.data?.business); // undefined
     
-    await sessionController.deleteSessionAll(); // End session for this user in all devices
-    console.log(ctx.session?.userKey); // undefined
+    // endSessionAll: Ends all registered sessions for this user in all devices.
+    await lambder.getSessionController(ctx).endSessionAll(); 
+    console.log(ctx.session?.sessionKey); // undefined
     console.log(ctx.session?.data?.business); // undefined
 
 });
@@ -296,6 +352,7 @@ lambder.addApi("getCompanyName", async (ctx, res) => {
         headers, // Request Headers in an object. Exp: { "User-Agent": "....", ... }
         apiName, // In this function it would return "getCompanyName"
         apiPayload, // Same as post.payload 
+        session, // Stores session. Only available in addSessionRoute and addSessionApi, otherwise null.
     } = ctx;
     return res.json({});
 });

package/dist/Lambder.d.ts

@@ -2,9 +2,10 @@ import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import { type LambderSessionContext } from "./LambderSession.js";
+import { type LambderSessionContext } from "./LambderSessionManager.js";
+import LambderSessionController from "./LambderSessionController.js";
 type Path = `/${string}`;
-type LambderRenderContext = {
+export type LambderRenderContext = {
     host: string;
     path: string;
     pathParams: Record<string, any> | null;
@@ -17,6 +18,9 @@ type LambderRenderContext = {
     headers: APIGatewayProxyEventHeaders;
     session: LambderSessionContext | null;
     lambdaContext: Context;
+    _otherInternal: {
+        isApiCall: boolean;
+    };
 };
 type LambderModuleFunction = (lambderInstance: Lambder) => void | Promise<void>;
 type ConditionFunction = (ctx: LambderRenderContext) => boolean;
@@ -41,7 +45,7 @@ export default class Lambder {
     private routeFallbackHandler;
     private apiFallbackHandler;
     utils: LambderUtils;
-    private lambderSession?;
+    private lambderSessionManager?;
     private sessionTokenCookieKey;
     private sessionCsrfCookieKey;
     constructor({ publicPath, apiPath, ejsPath, apiVersion }: {
@@ -63,11 +67,8 @@ export default class Lambder {
     setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction): void;
     setApiFallbackHandler(apiFallbackHandler: ApiFallbackHandlerFunction): void;
     setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction): void;
-    getPatternMatch(pattern: string, path: string): Record<string, any>;
-    testPatternMatch(pattern: string, path: string): boolean;
-    private fetchSession;
-    private validateSessionForRoute;
-    private validateSessionForAPI;
+    private getPatternMatch;
+    private testPatternMatch;
     private handleNoMatchedAction;
     addModule(moduleFn: LambderModuleFunction): Promise<void>;
     importModule(moduleImport: Promise<{
@@ -81,12 +82,7 @@ export default class Lambder {
     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): {
-        startSession: (userKey: string, data?: any, ttlInSeconds?: number) => Promise<LambderSessionContext>;
-        updateSessionData: (newData: any) => Promise<LambderSessionContext>;
-        deleteSession: () => Promise<void>;
-        deleteSessionAll: () => Promise<void>;
-    };
+    getSessionController(ctx: LambderRenderContext): LambderSessionController;
     getResponseBuilder(): LambderResponseBuilder;
     private getResolver;
     render(event: APIGatewayProxyEvent, lambdaContext: Context): Promise<LambderResolverResponse>;

package/dist/Lambder.js

@@ -4,7 +4,8 @@ import { match } from "path-to-regexp";
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import LambderSession from "./LambderSession.js";
+import LambderSessionManager from "./LambderSessionManager.js";
+import LambderSessionController from "./LambderSessionController.js";
 export const createContext = (event, lambdaContext, apiPath) => {
     const host = event.headers.Host || event.headers.host || "";
     const path = event.path;
@@ -27,10 +28,16 @@ export const createContext = (event, lambdaContext, apiPath) => {
     }
     catch (e) { }
     // Parse api variables
-    const isAPICall = method === "POST" && apiPath && path === apiPath && post.apiName;
-    const apiName = isAPICall ? post.apiName : null;
-    const apiPayload = isAPICall ? post.payload : null;
-    return { host, path, pathParams, method, get, post, cookie, apiName, apiPayload, headers, session, lambdaContext };
+    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
+    const apiName = isApiCall ? post.apiName : null;
+    const apiPayload = isApiCall ? post.payload : null;
+    return {
+        host, path, pathParams, method,
+        get, post, cookie,
+        apiName, apiPayload,
+        headers, session, lambdaContext,
+        _otherInternal: { isApiCall }
+    };
 };
 export default class Lambder {
     apiPath;
@@ -44,7 +51,7 @@ export default class Lambder {
     routeFallbackHandler = null;
     apiFallbackHandler = null;
     utils;
-    lambderSession;
+    lambderSessionManager;
     sessionTokenCookieKey = "LMDRSESSIONTKID";
     sessionCsrfCookieKey = "LMDRSESSIONCSTK";
     constructor({ publicPath, apiPath, ejsPath, apiVersion }) {
@@ -64,7 +71,7 @@ export default class Lambder {
         this.isCorsEnabled = isCorsEnabled;
     }
     enableDdbSession({ tableName, tableRegion, sessionSalt }, { partitionKey, sortKey } = { partitionKey: "pk", sortKey: "sk" }) {
-        this.lambderSession = new LambderSession({
+        this.lambderSessionManager = new LambderSessionManager({
             tableName, tableRegion, partitionKey, sortKey, sessionSalt
         });
     }
@@ -90,32 +97,6 @@ export default class Lambder {
     testPatternMatch(pattern, path) {
         return (match(pattern, { decode: decodeURIComponent }))(path) !== false;
     }
-    async fetchSession(ctx) {
-        if (!this.lambderSession)
-            throw "Session not found";
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        if (!sessionToken)
-            throw "Session not found";
-        const session = await this.lambderSession.getSession(sessionToken);
-        ctx.session = session;
-        return true;
-    }
-    ;
-    validateSessionForRoute(ctx) {
-        if (!this.lambderSession)
-            return false;
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        return this.lambderSession.isSessionValid(ctx.session, sessionToken, null, true);
-    }
-    ;
-    validateSessionForAPI(ctx) {
-        if (!this.lambderSession)
-            return false;
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        const csrfToken = ctx.post?.token;
-        return this.lambderSession.isSessionValid(ctx.session, sessionToken, csrfToken);
-    }
-    ;
     async handleNoMatchedAction(ctx, resolver) {
         for (const hook of this.hookList["fallback"]) {
             await hook.hookFn(ctx, resolver);
@@ -165,10 +146,7 @@ export default class Lambder {
                     (typeof condition === "function" && condition(ctx)) ||
                     (condition?.constructor == RegExp && condition.test(ctx.path)))),
             actionFn: async (ctx, resolver) => {
-                await this.fetchSession(ctx);
-                const isSessionValid = this.validateSessionForRoute(ctx);
-                if (!isSessionValid)
-                    throw new Error("Session not found");
+                await this.getSessionController(ctx).fetchSession();
                 if (typeof condition === "string") {
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
                 }
@@ -195,10 +173,7 @@ export default class Lambder {
                 (typeof apiName === "function" && apiName(ctx)) ||
                 (apiName?.constructor == RegExp && apiName.test(ctx.apiName)))),
             actionFn: async (ctx, resolver) => {
-                await this.fetchSession(ctx);
-                const isSessionValid = this.validateSessionForAPI(ctx);
-                if (!isSessionValid)
-                    throw new Error("Session not found");
+                await this.getSessionController(ctx).fetchSession();
                 return await actionFn(ctx, resolver);
             }
         });
@@ -214,38 +189,13 @@ export default class Lambder {
         }
     }
     getSessionController(ctx) {
-        return {
-            startSession: async (userKey, data, ttlInSeconds) => {
-                if (!this.lambderSession)
-                    throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                ctx.session = await this.lambderSession.createSession(userKey, data, ttlInSeconds);
-                return ctx.session;
-            },
-            updateSessionData: async (newData) => {
-                if (!this.lambderSession)
-                    throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if (!ctx.session)
-                    throw "Session not found.";
-                ctx.session = await this.lambderSession.updateSessionData(ctx.session, newData);
-                return ctx.session;
-            },
-            deleteSession: async () => {
-                if (!this.lambderSession)
-                    throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if (!ctx.session)
-                    throw "Session not found.";
-                await this.lambderSession.deleteSession(ctx.session);
-                ctx.session = null;
-            },
-            deleteSessionAll: async () => {
-                if (!this.lambderSession)
-                    throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if (!ctx.session)
-                    throw "Session not found.";
-                await this.lambderSession.deleteSessionAll(ctx.session);
-                ctx.session = null;
-            },
-        };
+        if (!this.lambderSessionManager)
+            throw new Error("Session is not enabled. Use lambder.enableDdbSession(...) to enable.");
+        return new LambderSessionController({
+            lambderSessionManager: this.lambderSessionManager,
+            sessionTokenCookieKey: this.sessionTokenCookieKey,
+            ctx,
+        });
     }
     getResponseBuilder() {
         return new LambderResponseBuilder({

package/dist/LambderSessionController.d.ts

@@ -0,0 +1,21 @@
+import { LambderRenderContext } from "./Lambder.js";
+import type LambderSessionManager from "./LambderSessionManager.js";
+import type { LambderSessionContext } from "./LambderSessionManager.js";
+export default class LambderSessionController {
+    lambderSessionManager: LambderSessionManager;
+    sessionTokenCookieKey: string;
+    ctx: LambderRenderContext;
+    constructor({ lambderSessionManager, sessionTokenCookieKey, ctx, }: {
+        lambderSessionManager: LambderSessionManager;
+        sessionTokenCookieKey: string;
+        ctx: LambderRenderContext;
+    });
+    private areRequestSessionTokensValid;
+    createSession(sessionKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext>;
+    fetchSession(): Promise<LambderSessionContext>;
+    fetchSessionIfExists(): Promise<LambderSessionContext | null>;
+    isSessionValid(session: any): boolean;
+    updateSessionData(newData: any): Promise<LambderSessionContext>;
+    endSession(): Promise<void>;
+    endSessionAll(): Promise<void>;
+}

package/dist/LambderSessionController.js

@@ -0,0 +1,88 @@
+export default class LambderSessionController {
+    lambderSessionManager;
+    sessionTokenCookieKey;
+    ctx;
+    constructor({ lambderSessionManager, sessionTokenCookieKey, ctx, }) {
+        this.ctx = ctx;
+        this.sessionTokenCookieKey = sessionTokenCookieKey;
+        this.lambderSessionManager = lambderSessionManager;
+    }
+    ;
+    areRequestSessionTokensValid() {
+        const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+        const isSessionTokenValid = sessionToken && sessionToken?.split(":")?.length === 2;
+        if (this.ctx._otherInternal.isApiCall) {
+            const csrfToken = this.ctx.post?.token;
+            const isCsrfTokenValid = typeof csrfToken === "string" && csrfToken.length > 0;
+            return isSessionTokenValid && isCsrfTokenValid;
+        }
+        else {
+            return isSessionTokenValid;
+        }
+    }
+    ;
+    async createSession(sessionKey, data, ttlInSeconds) {
+        this.ctx.session = await this.lambderSessionManager.createSession(sessionKey, data, ttlInSeconds);
+        return this.ctx.session;
+    }
+    ;
+    async fetchSession() {
+        if (!this.areRequestSessionTokensValid()) {
+            throw new Error("Session tokens are invalid");
+        }
+        const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+        if (!sessionToken)
+            throw new Error("Session token not found");
+        const session = await this.lambderSessionManager.getSession(sessionToken);
+        if (!session)
+            throw new Error("Session not found");
+        if (!this.isSessionValid(session))
+            throw new Error("Invalid session");
+        this.ctx.session = session;
+        return session;
+    }
+    ;
+    async fetchSessionIfExists() {
+        try {
+            return await this.fetchSession();
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    ;
+    isSessionValid(session) {
+        if (this.ctx._otherInternal.isApiCall) {
+            const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+            const csrfToken = this.ctx.post?.token;
+            return this.lambderSessionManager.isSessionValid(session, sessionToken, csrfToken);
+        }
+        else {
+            const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+            return this.lambderSessionManager.isSessionValid(session, sessionToken, null, true);
+        }
+    }
+    ;
+    async updateSessionData(newData) {
+        if (!this.ctx.session)
+            throw new Error("Session not found.");
+        this.ctx.session = await this.lambderSessionManager.updateSessionData(this.ctx.session, newData);
+        return this.ctx.session;
+    }
+    ;
+    async endSession() {
+        if (!this.ctx.session)
+            throw new Error("Session not found.");
+        await this.lambderSessionManager.deleteSession(this.ctx.session);
+        this.ctx.session = null;
+    }
+    ;
+    async endSessionAll() {
+        if (!this.ctx.session)
+            throw new Error("Session not found.");
+        await this.lambderSessionManager.deleteSessionAll(this.ctx.session);
+        this.ctx.session = null;
+    }
+    ;
+}
+;

package/dist/{LambderSession.d.ts → LambderSessionManager.d.ts}

@@ -2,13 +2,13 @@ export type LambderSessionContext = {
     [x: string]: any;
     sessionToken: string;
     csrfToken: string;
-    userKey: string;
+    sessionKey: string;
     data: any;
     createdAt: number;
     expiresAt: number;
     ttlInSeconds: number;
 };
-export default class LambderSession {
+export default class LambderSessionManager {
     private tableName;
     private sessionSalt;
     private partitionKey;
@@ -27,7 +27,7 @@ export default class LambderSession {
     private ddbDeleteItem;
     private ddbQueryAllByPartitionKey;
     private ddbDeleteAllByPartitionKey;
-    createSession(userKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext>;
+    createSession(sessionKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext>;
     updateSessionData(session: LambderSessionContext, newData?: any): Promise<LambderSessionContext>;
     getSession(sessionToken: string): Promise<LambderSessionContext | null>;
     isSessionValid(session: any, sessionToken: any, csrfToken: any, skipCsrfTokenCheck?: boolean): boolean;

package/dist/{LambderSession.js → LambderSessionManager.js}

@@ -1,7 +1,7 @@
 import crypto from "crypto";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClient, QueryCommand, DeleteCommand, PutCommand, GetCommand } from "@aws-sdk/lib-dynamodb";
-export default class LambderSession {
+export default class LambderSessionManager {
     tableName;
     sessionSalt;
     partitionKey;
@@ -63,18 +63,18 @@ export default class LambderSession {
             }));
         }
     }
-    async createSession(userKey, data = {}, ttlInSeconds = 30 * 24 * 60 * 60) {
-        const userKeyHash = this.sessionUserKeyHasher(userKey);
+    async createSession(sessionKey, data = {}, ttlInSeconds = 30 * 24 * 60 * 60) {
+        const sessionKeyHash = this.sessionUserKeyHasher(sessionKey);
         const sessionSortKey = crypto.randomBytes(32).toString("hex");
-        const sessionToken = `${userKeyHash}:${sessionSortKey}`;
+        const sessionToken = `${sessionKeyHash}:${sessionSortKey}`;
         const csrfToken = crypto.randomBytes(8).toString("hex");
         const createdAt = Math.floor(Date.now() / 1000);
         const expiresAt = Number(createdAt) + Number(ttlInSeconds);
         const session = {
-            [this.partitionKey]: userKeyHash,
+            [this.partitionKey]: sessionKeyHash,
             [this.sortKey]: sessionSortKey,
             sessionToken, csrfToken,
-            userKey, data,
+            sessionKey, data,
             createdAt, expiresAt, ttlInSeconds
         };
         await this.ddbPutItem(session);
@@ -82,32 +82,32 @@ export default class LambderSession {
     }
     async updateSessionData(session, newData) {
         if (!session)
-            throw "Invalid session";
+            throw new Error("Invalid session");
         session.data = newData;
         await this.ddbPutItem(session);
         return session;
     }
     async getSession(sessionToken) {
-        const [userKeyHash, sessionSortKey] = sessionToken.split(":");
-        if (!userKeyHash || !sessionSortKey)
+        const [sessionKeyHash, sessionSortKey] = sessionToken.split(":");
+        if (!sessionKeyHash || !sessionSortKey)
             return null;
         try {
             let session = await this.ddbGetItem({
-                [this.partitionKey]: userKeyHash,
+                [this.partitionKey]: sessionKeyHash,
                 [this.sortKey]: sessionSortKey
             });
             if (!session)
-                throw "Session not found";
+                throw new Error("Session not found");
             if (!session.sessionToken || session.sessionToken !== sessionToken)
-                throw "Not found: session.sessionToken";
+                throw new Error("Not found: session.sessionToken");
             if (!session.csrfToken)
-                throw "Not found: session.csrfToken";
-            if (!session.userKey)
-                throw "Not found: session.userKey";
+                throw new Error("Not found: session.csrfToken");
+            if (!session.sessionKey)
+                throw new Error("Not found: session.sessionKey");
             if (!session.createdAt)
-                throw "Not found: session.createdAt";
+                throw new Error("Not found: session.createdAt");
             if (!session.expiresAt || session.expiresAt < Date.now() / 1000)
-                throw "Not found: session.expiresAt";
+                throw new Error("Not found: session.expiresAt");
             return session;
         }
         catch (err) {
@@ -124,7 +124,7 @@ export default class LambderSession {
             return false;
         if (!session.csrfToken)
             return false;
-        if (!session.userKey)
+        if (!session.sessionKey)
             return false;
         if (!session.createdAt)
             return false;

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
-export { default as LambderSession } from "./LambderSession.js";
+export { default as LambderSessionManager } from "./LambderSessionManager.js";

package/dist/index.js

@@ -3,4 +3,4 @@ export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
-export { default as LambderSession } from "./LambderSession.js";
+export { default as LambderSessionManager } from "./LambderSessionManager.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.114",
+  "version": "1.0.116",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Lambder.ts

@@ -6,11 +6,12 @@ import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from
 import LambderResolver from "./LambderResolver.js";
 import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
 import LambderUtils from "./LambderUtils.js";
-import LambderSession, { type LambderSessionContext } from "./LambderSession.js";
+import LambderSessionManager, { type LambderSessionContext } from "./LambderSessionManager.js";
+import LambderSessionController from "./LambderSessionController.js";
 
 type Path = `/${string}`;
 
-type LambderRenderContext = {
+export type LambderRenderContext = {
     host: string;
     path: string;
     pathParams: Record<string, any> | null;
@@ -23,6 +24,7 @@ type LambderRenderContext = {
     headers: APIGatewayProxyEventHeaders;
     session: LambderSessionContext|null;
     lambdaContext: Context;
+    _otherInternal: { isApiCall: boolean };
 };
 
 type LambderModuleFunction = (lambderInstance: Lambder) => void | Promise<void>;
@@ -55,6 +57,7 @@ export const createContext = (
     const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
     const headers = event.headers;
     const session = null;
+    
     // Decode body for the post
     let post: Record<string, any> = {};
     try {
@@ -63,11 +66,18 @@ export const createContext = (
         catch(e){ post = querystring.parse(decodedBody) || {}; }
     }catch(e){}
     // Parse api variables
-    const isAPICall = method === "POST" && apiPath && path === apiPath && post.apiName;
-    const apiName:string = isAPICall ? post.apiName : null;
-    const apiPayload:string = isAPICall ? post.payload : null;
 
-    return { host, path, pathParams, method, get, post, cookie, apiName, apiPayload, headers, session, lambdaContext };
+    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
+    const apiName:string = isApiCall ? post.apiName : null;
+    const apiPayload:string = isApiCall ? post.payload : null;
+
+    return { 
+        host, path, pathParams, method, 
+        get, post, cookie, 
+        apiName, apiPayload, 
+        headers, session, lambdaContext, 
+        _otherInternal: { isApiCall } 
+    };
 }
 
 
@@ -90,7 +100,7 @@ export default class Lambder {
 
     public utils: LambderUtils;
 
-    private lambderSession?: LambderSession;
+    private lambderSessionManager?: LambderSessionManager;
     private sessionTokenCookieKey = "LMDRSESSIONTKID";
     private sessionCsrfCookieKey = "LMDRSESSIONCSTK";
     
@@ -121,7 +131,7 @@ export default class Lambder {
         { tableName, tableRegion, sessionSalt }: { tableName: string; tableRegion: string; sessionSalt: string; }, 
         { partitionKey, sortKey }: { partitionKey: string, sortKey: string } = { partitionKey: "pk", sortKey: "sk" }
     ){
-        this.lambderSession = new LambderSession({
+        this.lambderSessionManager = new LambderSessionManager({
             tableName, tableRegion, partitionKey, sortKey, sessionSalt
         });
     }
@@ -140,37 +150,15 @@ export default class Lambder {
     setGlobalErrorHandler(globalErrorHandler: GlobalErrorHandlerFunction){
         this.globalErrorHandler = globalErrorHandler;
     }
-    getPatternMatch(pattern: string, path: string): Record<string, any> {
+    private getPatternMatch(pattern: string, path: string): Record<string, any> {
         const result = (match(pattern, { decode: decodeURIComponent }))(path);
         if(!result) return {};
         return result?.params || {};
     }
-    testPatternMatch(pattern: string, path: string): boolean{
+    private testPatternMatch(pattern: string, path: string): boolean{
         return (match(pattern, { decode: decodeURIComponent }))(path) !== false;
     }
-
-    private async fetchSession (ctx: LambderRenderContext): Promise<boolean>{
-        if(!this.lambderSession) throw "Session not found";
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        if(!sessionToken) throw "Session not found";
-        const session = await this.lambderSession.getSession(sessionToken);
-        ctx.session = session;
-        return true;
-    };
-
-    private validateSessionForRoute (ctx: LambderRenderContext): boolean{
-        if(!this.lambderSession) return false;
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        return this.lambderSession.isSessionValid(ctx.session, sessionToken, null, true);
-    };
-
-    private validateSessionForAPI (ctx: LambderRenderContext): boolean{
-        if(!this.lambderSession) return false;
-        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
-        const csrfToken = ctx.post?.token;
-        return this.lambderSession.isSessionValid(ctx.session, sessionToken, csrfToken);
-    };
-
+    
     private async handleNoMatchedAction(ctx: LambderRenderContext, resolver: LambderResolver){
         for(const hook of this.hookList["fallback"]){  await hook.hookFn(ctx, resolver); }
 
@@ -227,9 +215,8 @@ export default class Lambder {
                 )
             ), 
             actionFn: async (ctx:LambderRenderContext, resolver: LambderResolver) => {
-                await this.fetchSession(ctx);
-                const isSessionValid = this.validateSessionForRoute(ctx);
-                if(!isSessionValid) throw new Error("Session not found");
+                await this.getSessionController(ctx).fetchSession();
+
                 if(typeof condition === "string"){
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
                 }else if(condition?.constructor == RegExp){
@@ -263,9 +250,7 @@ export default class Lambder {
                 )
             ), 
             actionFn: async (ctx:LambderRenderContext, resolver: LambderResolver) => {
-                await this.fetchSession(ctx);
-                const isSessionValid = this.validateSessionForAPI(ctx);
-                if(!isSessionValid) throw new Error("Session not found");
+                await this.getSessionController(ctx).fetchSession();
                 return await actionFn(ctx, resolver);
             }
         });
@@ -288,35 +273,17 @@ export default class Lambder {
         }
     }
 
-    public getSessionController(ctx: LambderRenderContext){
-        return {
-            startSession: async (userKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext> => {
-                if(!this.lambderSession) throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                ctx.session = await this.lambderSession.createSession(userKey, data, ttlInSeconds);
-                return ctx.session;
-            },
-            updateSessionData: async (newData: any): Promise<LambderSessionContext> => {
-                if(!this.lambderSession) throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if(!ctx.session) throw "Session not found.";
-                ctx.session = await this.lambderSession.updateSessionData(ctx.session, newData);
-                return ctx.session;
-            },
-            deleteSession: async () => {
-                if(!this.lambderSession) throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if(!ctx.session) throw "Session not found.";
-                await this.lambderSession.deleteSession(ctx.session);
-                ctx.session = null
-            },
-            deleteSessionAll: async () => {
-                if(!this.lambderSession) throw "Session is not enabled. Use lambder.enableDdbSession(...) to configure.";
-                if(!ctx.session) throw "Session not found.";
-                await this.lambderSession.deleteSessionAll(ctx.session);
-                ctx.session = null
-            },
-        }
+    getSessionController(ctx: LambderRenderContext): LambderSessionController{
+        if(!this.lambderSessionManager) throw new Error("Session is not enabled. Use lambder.enableDdbSession(...) to enable.");
+
+        return new LambderSessionController({
+            lambderSessionManager: this.lambderSessionManager,
+            sessionTokenCookieKey: this.sessionTokenCookieKey,
+            ctx, 
+        });
     }
 
-    public getResponseBuilder(){
+    getResponseBuilder(){
         return new LambderResponseBuilder({
             isCorsEnabled: this.isCorsEnabled, 
             publicPath: this.publicPath,

package/src/LambderSessionController.ts

@@ -0,0 +1,94 @@
+import { LambderRenderContext } from "./Lambder.js";
+import type LambderSessionManager from "./LambderSessionManager.js";
+import type { LambderSessionContext } from "./LambderSessionManager.js";
+
+export default class LambderSessionController {
+    lambderSessionManager: LambderSessionManager;
+    sessionTokenCookieKey: string;
+    ctx: LambderRenderContext;
+
+    constructor(
+        { 
+            lambderSessionManager,
+            sessionTokenCookieKey,
+            ctx,
+        }: {
+            lambderSessionManager: LambderSessionManager,
+            sessionTokenCookieKey: string,
+            ctx: LambderRenderContext,
+        }
+    ){
+        this.ctx = ctx;
+        this.sessionTokenCookieKey = sessionTokenCookieKey;
+        this.lambderSessionManager = lambderSessionManager;
+    };
+
+    private areRequestSessionTokensValid(): boolean {
+        const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+        const isSessionTokenValid = sessionToken && sessionToken?.split(":")?.length === 2;
+
+        if(this.ctx._otherInternal.isApiCall){
+            const csrfToken = this.ctx.post?.token;
+            const isCsrfTokenValid = typeof csrfToken === "string" && csrfToken.length > 0
+            return isSessionTokenValid && isCsrfTokenValid;
+        }else{
+            return isSessionTokenValid;
+        }
+    };
+
+    async createSession (sessionKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext> {
+        this.ctx.session = await this.lambderSessionManager.createSession(sessionKey, data, ttlInSeconds);
+        return this.ctx.session;
+    };
+
+    async fetchSession (): Promise<LambderSessionContext>{
+        if(!this.areRequestSessionTokensValid()){ throw new Error("Session tokens are invalid"); }
+
+        const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+        if(!sessionToken) throw new Error("Session token not found");
+        
+        const session = await this.lambderSessionManager.getSession(sessionToken);
+        if(!session) throw new Error("Session not found");
+        
+        if(!this.isSessionValid(session)) throw new Error("Invalid session");
+        this.ctx.session = session;
+        return session;
+    };
+
+    async fetchSessionIfExists (): Promise<LambderSessionContext|null> {
+        try {
+            return await this.fetchSession();
+        }catch(err){
+            return null;
+        }
+    };
+
+    isSessionValid(session: any): boolean {
+        if(this.ctx._otherInternal.isApiCall){
+            const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+            const csrfToken = this.ctx.post?.token;
+            return this.lambderSessionManager.isSessionValid(session, sessionToken, csrfToken);
+        }else{
+            const sessionToken = this.ctx.cookie?.[this.sessionTokenCookieKey];
+            return this.lambderSessionManager.isSessionValid(session, sessionToken, null, true);
+        }
+    };
+
+    async updateSessionData (newData: any): Promise<LambderSessionContext> {
+        if(!this.ctx.session) throw new Error("Session not found.");
+        this.ctx.session = await this.lambderSessionManager.updateSessionData(this.ctx.session, newData);
+        return this.ctx.session;
+    };
+
+    async endSession (){
+        if(!this.ctx.session) throw new Error("Session not found.");
+        await this.lambderSessionManager.deleteSession(this.ctx.session);
+        this.ctx.session = null
+    };
+
+    async endSessionAll (){
+        if(!this.ctx.session) throw new Error("Session not found.");
+        await this.lambderSessionManager.deleteSessionAll(this.ctx.session);
+        this.ctx.session = null
+    };
+};

package/src/{LambderSession.ts → LambderSessionManager.ts}

@@ -6,7 +6,7 @@ export type LambderSessionContext = {
     [x: string]: any;
     sessionToken: string;
     csrfToken: string;
-    userKey: string;
+    sessionKey: string;
     data: any;
     createdAt: number;
     expiresAt: number;
@@ -14,7 +14,7 @@ export type LambderSessionContext = {
 };
 
 
-export default class LambderSession{
+export default class LambderSessionManager{
     private tableName: string;
     private sessionSalt: string;
     private partitionKey: string;
@@ -94,22 +94,22 @@ export default class LambderSession{
     }
 
     public async createSession(
-        userKey: string, 
+        sessionKey: string, 
         data: any = {}, 
         ttlInSeconds:number = 30*24*60*60
     ): Promise<LambderSessionContext> {
-        const userKeyHash = this.sessionUserKeyHasher(userKey);
+        const sessionKeyHash = this.sessionUserKeyHasher(sessionKey);
         const sessionSortKey = crypto.randomBytes(32).toString("hex");
-        const sessionToken = `${userKeyHash}:${sessionSortKey}`;
+        const sessionToken = `${sessionKeyHash}:${sessionSortKey}`;
         const csrfToken = crypto.randomBytes(8).toString("hex");
         const createdAt = Math.floor(Date.now()/1000);
         const expiresAt = Number(createdAt) + Number(ttlInSeconds);
     
         const session = {
-            [this.partitionKey]: userKeyHash, 
+            [this.partitionKey]: sessionKeyHash, 
             [this.sortKey]: sessionSortKey,
             sessionToken, csrfToken,
-            userKey, data, 
+            sessionKey, data, 
             createdAt, expiresAt, ttlInSeconds
         };
         await this.ddbPutItem(session);
@@ -120,26 +120,26 @@ export default class LambderSession{
         session: LambderSessionContext,
         newData?: any
     ): Promise<LambderSessionContext> {
-        if(!session) throw "Invalid session";
+        if(!session) throw new Error("Invalid session");
         session.data = newData;
         await this.ddbPutItem(session);
         return session;
     }
 
     public async getSession(sessionToken: string): Promise<LambderSessionContext|null>{
-        const [ userKeyHash, sessionSortKey ] = sessionToken.split(":");
-        if(!userKeyHash || !sessionSortKey) return null;
+        const [ sessionKeyHash, sessionSortKey ] = sessionToken.split(":");
+        if(!sessionKeyHash || !sessionSortKey) return null;
         try{
             let session = await this.ddbGetItem({ 
-                [this.partitionKey]: userKeyHash, 
+                [this.partitionKey]: sessionKeyHash, 
                 [this.sortKey]: sessionSortKey
             });
-            if(!session) throw "Session not found";
-            if(!session.sessionToken || session.sessionToken !== sessionToken) throw "Not found: session.sessionToken";
-            if(!session.csrfToken) throw "Not found: session.csrfToken";
-            if(!session.userKey) throw "Not found: session.userKey";
-            if(!session.createdAt) throw "Not found: session.createdAt";
-            if(!session.expiresAt || session.expiresAt < Date.now()/1000) throw "Not found: session.expiresAt";
+            if(!session) throw new Error("Session not found");
+            if(!session.sessionToken || session.sessionToken !== sessionToken) throw new Error("Not found: session.sessionToken");
+            if(!session.csrfToken) throw new Error("Not found: session.csrfToken");
+            if(!session.sessionKey) throw new Error("Not found: session.sessionKey");
+            if(!session.createdAt) throw new Error("Not found: session.createdAt");
+            if(!session.expiresAt || session.expiresAt < Date.now()/1000) throw new Error("Not found: session.expiresAt");
             return session;
         }catch(err){
             return null;
@@ -151,7 +151,7 @@ export default class LambderSession{
         if(!sessionToken || typeof sessionToken !== "string") return false;
         if(session.sessionToken !== sessionToken) return false;
         if(!session.csrfToken) return false;
-        if(!session.userKey) return false;
+        if(!session.sessionKey) return false;
         if(!session.createdAt) return false;
         if(!session.expiresAt || session.expiresAt < Date.now()/1000) return false;
         if(!skipCsrfTokenCheck){

package/src/index.ts

@@ -4,4 +4,4 @@ export default Lambder;
 export { default as LambderCaller } from "./LambderCaller.js";
 export { default as LambderResponseBuilder } from "./LambderResponseBuilder.js";
 export { default as LambderResolver } from "./LambderResolver.js";
-export { default as LambderSession } from "./LambderSession.js";
+export { default as LambderSessionManager } from "./LambderSessionManager.js";