lambder 1.0.105 → 1.0.109

package/dist/Lambder.d.ts

@@ -2,16 +2,8 @@ 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";
 type Path = `/${string}`;
-type LambderSession = {
-    userId: string;
-    userIdHash: string;
-    sessionHash: string;
-    csrfToken: string;
-    createdTimeStamp: number;
-    expiresTimeStamp: number;
-    data: Record<string, any>;
-};
 type LambderRenderContext = {
     host: string;
     path: string;
@@ -23,7 +15,7 @@ type LambderRenderContext = {
     apiName: string;
     apiPayload: any;
     headers: APIGatewayProxyEventHeaders;
-    session: LambderSession | null;
+    session: LambderSessionContext | null;
     lambdaContext: Context;
 };
 type LambderModuleFunction = (lambderInstance: Lambder) => void | Promise<void>;
@@ -49,19 +41,34 @@ export default class Lambder {
     private routeFallbackHandler;
     private apiFallbackHandler;
     utils: LambderUtils;
-    constructor({ publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }: {
+    private lambderSession?;
+    private sessionTokenCookieKey;
+    private sessionCsrfCookieKey;
+    constructor({ publicPath, apiPath, ejsPath, apiVersion }: {
         publicPath: string;
         apiPath?: string;
         ejsPath?: string;
         apiVersion?: string;
         isCorsEnabled?: boolean;
     });
+    enableCORS(isCorsEnabled: boolean): void;
+    enableDdbSession({ tableName, tableRegion, sessionSalt }: {
+        tableName: string;
+        tableRegion: string;
+        sessionSalt: string;
+    }, { partitionKey, sortKey }?: {
+        partitionKey: string;
+        sortKey: string;
+    }): void;
+    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string): void;
     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 validateSession;
+    private fetchSession;
+    private validateSessionForRoute;
+    private validateSessionForAPI;
     private handleNoMatchedAction;
     addModule(moduleFn: LambderModuleFunction): Promise<void>;
     importModule(moduleImport: Promise<{

package/dist/Lambder.js

@@ -4,6 +4,7 @@ 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";
 export const createContext = (event, lambdaContext, apiPath) => {
     const host = event.headers.Host || event.headers.host || "";
     const path = event.path;
@@ -34,7 +35,7 @@ export const createContext = (event, lambdaContext, apiPath) => {
 export default class Lambder {
     apiPath;
     apiVersion;
-    isCorsEnabled;
+    isCorsEnabled = false;
     publicPath;
     ejsPath;
     actionList;
@@ -43,12 +44,14 @@ export default class Lambder {
     routeFallbackHandler = null;
     apiFallbackHandler = null;
     utils;
-    constructor({ publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }) {
+    lambderSession;
+    sessionTokenCookieKey = "LMDRSESSIONTKID";
+    sessionCsrfCookieKey = "LMDRSESSIONCSID";
+    constructor({ publicPath, apiPath, ejsPath, apiVersion }) {
         this.publicPath = publicPath || "/incorrect-path-not-found";
         this.ejsPath = ejsPath || "/incorrect-ejs-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
-        this.isCorsEnabled = isCorsEnabled ?? false;
         this.actionList = [];
         this.hookList = {
             "beforeRender": [],
@@ -57,6 +60,18 @@ export default class Lambder {
         };
         this.utils = new LambderUtils({ ejsPath });
     }
+    enableCORS(isCorsEnabled) {
+        this.isCorsEnabled = isCorsEnabled;
+    }
+    enableDdbSession({ tableName, tableRegion, sessionSalt }, { partitionKey, sortKey } = { partitionKey: "pk", sortKey: "sk" }) {
+        this.lambderSession = new LambderSession({
+            tableName, tableRegion, partitionKey, sortKey, sessionSalt
+        });
+    }
+    setSessionCookieKey(sessionTokenCookieKey, sessionCsrfCookieKey) {
+        this.sessionTokenCookieKey = sessionTokenCookieKey;
+        this.sessionCsrfCookieKey = sessionCsrfCookieKey;
+    }
     setRouteFallbackHandler(routeFallbackHandler) {
         this.routeFallbackHandler = routeFallbackHandler;
     }
@@ -75,26 +90,30 @@ export default class Lambder {
     testPatternMatch(pattern, path) {
         return (match(pattern, { decode: decodeURIComponent }))(path) !== false;
     }
-    async validateSession(ctx) {
-        const { session, apiName, post, cookie } = ctx;
-        if (!session)
-            return false;
-        if (!session.userId || !session.userIdHash || !session.sessionHash || !session.csrfToken)
-            return false;
-        if (!session.createdTimeStamp || !session.expiresTimeStamp)
+    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;
-        if (session.expiresTimeStamp > Date.now())
+        const sessionToken = ctx.cookie?.[this.sessionTokenCookieKey];
+        return this.lambderSession.isSessionValid(ctx.session, sessionToken, null, true);
+    }
+    ;
+    validateSessionForAPI(ctx) {
+        if (!this.lambderSession)
             return false;
-        if (apiName) {
-            if (!post.token)
-                return false;
-            if (post.token !== cookie.LMBDRTOKEN)
-                return false;
-            if (post.token !== session.csrfToken)
-                return false;
-        }
-        // Check DDB;
-        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) {
@@ -146,7 +165,8 @@ export default class Lambder {
                     (typeof condition === "function" && condition(ctx)) ||
                     (condition?.constructor == RegExp && condition.test(ctx.path)))),
             actionFn: async (ctx, resolver) => {
-                const isSessionValid = this.validateSession(ctx);
+                await this.fetchSession(ctx);
+                const isSessionValid = this.validateSessionForRoute(ctx);
                 if (!isSessionValid)
                     throw new Error("Session not found");
                 if (typeof condition === "string") {
@@ -175,7 +195,8 @@ export default class Lambder {
                 (typeof apiName === "function" && apiName(ctx)) ||
                 (apiName?.constructor == RegExp && apiName.test(ctx.apiName)))),
             actionFn: async (ctx, resolver) => {
-                const isSessionValid = this.validateSession(ctx);
+                await this.fetchSession(ctx);
+                const isSessionValid = this.validateSessionForAPI(ctx);
                 if (!isSessionValid)
                     throw new Error("Session not found");
                 return await actionFn(ctx, resolver);

package/dist/LambderCaller.d.ts

@@ -48,7 +48,7 @@ export default class LambderCaller {
         fetchStartedHandler?: FetchStartEventHandler;
         fetchEndedHandler?: FetchEndEventHandler;
     });
-    apiRaw<T>(apiName: string, payload?: any, options?: {
+    apiRaw<T = any>(apiName: string, payload?: any, options?: {
         headers?: Record<string, any>;
         versionExpiredHandler?: VoidFunction;
         sessionExpiredHandler?: VoidFunction;
@@ -58,7 +58,7 @@ export default class LambderCaller {
         errorHandler?: ErrorHandler;
         fetchStartedHandler?: FetchStartEventHandler;
         fetchEndedHandler?: FetchEndEventHandler;
-    }): Promise<LambderApiResponse<T> | null>;
-    api<T>(...params: Parameters<typeof LambderCaller.prototype.apiRaw>): Promise<T | null>;
+    }): Promise<LambderApiResponse<T> | null | undefined>;
+    api<T = any>(...params: Parameters<typeof LambderCaller.prototype.apiRaw>): Promise<T | null | undefined>;
 }
 export {};

package/dist/LambderCaller.js

@@ -116,8 +116,6 @@ export default class LambderCaller {
     // Use the same type for api but adjust the return type
     async api(...params) {
         const result = await this.apiRaw(...params);
-        if (!result)
-            return null;
-        return result.payload ?? null;
+        return result?.payload;
     }
 }

package/dist/LambderSession.d.ts

@@ -0,0 +1,35 @@
+export type LambderSessionContext = {
+    [x: string]: any;
+    sessionToken: string;
+    csrfToken: string;
+    userKey: string;
+    data: any;
+    createdAt: number;
+    expiresAt: number;
+    ttlInSeconds: number;
+};
+export default class LambderSession {
+    private tableName;
+    private sessionSalt;
+    private partitionKey;
+    private sortKey;
+    private ddbDocumentClient;
+    constructor({ tableName, tableRegion, partitionKey, sortKey, sessionSalt, }: {
+        tableName: string;
+        tableRegion: string;
+        partitionKey: string;
+        sortKey: string;
+        sessionSalt: string;
+    });
+    private sessionUserKeyHasher;
+    private ddbGetItem;
+    private ddbPutItem;
+    private ddbDeleteItem;
+    private ddbQueryAllByPartitionKey;
+    private ddbDeleteAllByPartitionKey;
+    createSession(userKey: string, data?: any, ttlInSeconds?: number): Promise<LambderSessionContext>;
+    getSession(sessionToken: string): Promise<LambderSessionContext | null>;
+    isSessionValid(session: any, sessionToken: any, csrfToken: any, skipCsrfTokenCheck?: boolean): boolean;
+    deleteSession(session: Record<string, any>): Promise<boolean>;
+    deleteSessionAll(session: Record<string, any>): Promise<boolean>;
+}

package/dist/LambderSession.js

@@ -0,0 +1,148 @@
+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 {
+    tableName;
+    sessionSalt;
+    partitionKey;
+    sortKey;
+    ddbDocumentClient;
+    constructor({ tableName, tableRegion, partitionKey, sortKey, sessionSalt, }) {
+        this.tableName = tableName;
+        this.sessionSalt = sessionSalt;
+        this.partitionKey = partitionKey;
+        this.sortKey = sortKey;
+        const ddbClient = new DynamoDBClient({ region: tableRegion });
+        this.ddbDocumentClient = DynamoDBDocumentClient.from(ddbClient);
+    }
+    sessionUserKeyHasher(password) {
+        return crypto.createHash("sha256")
+            .update(`${password}${this.sessionSalt}`)
+            .digest("hex");
+    }
+    async ddbGetItem(key) {
+        const response = await this.ddbDocumentClient.send(new GetCommand({ TableName: this.tableName, Key: key, ConsistentRead: true }));
+        if (response.Item)
+            return response.Item;
+        return null;
+    }
+    ;
+    async ddbPutItem(item) {
+        return await this.ddbDocumentClient.send(new PutCommand({ TableName: this.tableName, Item: item, }));
+    }
+    ;
+    async ddbDeleteItem(key) {
+        return await this.ddbDocumentClient.send(new DeleteCommand({ TableName: this.tableName, Key: key, }));
+    }
+    ;
+    async ddbQueryAllByPartitionKey(partitionValue) {
+        const params = {
+            TableName: this.tableName,
+            KeyConditionExpression: "#pk = :pv",
+            ExpressionAttributeNames: { "#pk": this.partitionKey },
+            ExpressionAttributeValues: { ":pv": partitionValue },
+        };
+        const queryResults = [];
+        do {
+            const { Items, LastEvaluatedKey } = await this.ddbDocumentClient.send(new QueryCommand(params));
+            if (Items)
+                queryResults.push(...Items);
+            params.ExclusiveStartKey = LastEvaluatedKey;
+            if (typeof LastEvaluatedKey == "undefined")
+                return queryResults;
+            // eslint-disable-next-line no-constant-condition
+        } while (true);
+    }
+    ;
+    async ddbDeleteAllByPartitionKey(partitionValue) {
+        const queryResults = await this.ddbQueryAllByPartitionKey(partitionValue);
+        for (const item of queryResults) {
+            await this.ddbDocumentClient.send(new DeleteCommand({
+                TableName: this.tableName,
+                Key: { [this.partitionKey]: partitionValue, [this.sortKey]: item[this.sortKey] }
+            }));
+        }
+    }
+    async createSession(userKey, data = {}, ttlInSeconds = 30 * 24 * 60 * 60) {
+        const userKeyHash = this.sessionUserKeyHasher(userKey);
+        const sessionSortKey = crypto.randomBytes(32).toString("hex");
+        const sessionToken = `${userKeyHash}:${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.sortKey]: sessionSortKey,
+            sessionToken, csrfToken,
+            userKey, data,
+            createdAt, expiresAt, ttlInSeconds
+        };
+        await this.ddbPutItem(session);
+        return session;
+    }
+    async getSession(sessionToken) {
+        const [userKeyHash, sessionSortKey] = sessionToken.split(":");
+        if (!userKeyHash || !sessionSortKey)
+            return null;
+        try {
+            let session = await this.ddbGetItem({
+                [this.partitionKey]: userKeyHash,
+                [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";
+            return session;
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    ;
+    isSessionValid(session, sessionToken, csrfToken, skipCsrfTokenCheck = false) {
+        if (!session)
+            return false;
+        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.createdAt)
+            return false;
+        if (!session.expiresAt || session.expiresAt < Date.now() / 1000)
+            return false;
+        if (!skipCsrfTokenCheck) {
+            if (!csrfToken || typeof csrfToken !== "string")
+                return false;
+            if (session.csrfToken !== csrfToken)
+                return false;
+        }
+        return true;
+    }
+    async deleteSession(session) {
+        await this.ddbDeleteItem({
+            [this.partitionKey]: session[this.partitionKey],
+            [this.sortKey]: session[this.sortKey],
+        });
+        return true;
+    }
+    ;
+    async deleteSessionAll(session) {
+        await this.ddbDeleteAllByPartitionKey(session[this.partitionKey]);
+        return true;
+    }
+    ;
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "1.0.105",
+  "version": "1.0.109",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,6 +13,8 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.574.0",
+    "@aws-sdk/lib-dynamodb": "^3.574.0",
     "cookie": "^0.6.0",
     "ejs": "^3.1.9",
     "js-cookie": "^3.0.5",

package/src/Lambder.ts

@@ -6,19 +6,10 @@ 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";
 
 type Path = `/${string}`;
 
-type LambderSession = {
-    userId: string,
-    userIdHash: string;
-    sessionHash: string;
-    csrfToken: string;
-    createdTimeStamp: number;
-    expiresTimeStamp: number;
-    data: Record<string, any>;
-};
-
 type LambderRenderContext = {
     host: string;
     path: string;
@@ -30,7 +21,7 @@ type LambderRenderContext = {
     apiName: string;
     apiPayload: any;
     headers: APIGatewayProxyEventHeaders;
-    session: LambderSession|null;
+    session: LambderSessionContext|null;
     lambdaContext: Context;
 };
 
@@ -83,7 +74,7 @@ export const createContext = (
 export default class Lambder {
     public apiPath: string;
     public apiVersion: null|string;
-    public isCorsEnabled: boolean;
+    public isCorsEnabled: boolean = false;
     public publicPath: string;
     public ejsPath: string;
     
@@ -99,16 +90,18 @@ export default class Lambder {
 
     public utils: LambderUtils;
 
+    private lambderSession?: LambderSession;
+    private sessionTokenCookieKey = "LMDRSESSIONTKID";
+    private sessionCsrfCookieKey = "LMDRSESSIONCSID";
     
     constructor(
-        { publicPath, apiPath, ejsPath, apiVersion, isCorsEnabled }: 
+        { publicPath, apiPath, ejsPath, apiVersion }: 
         { publicPath: string, apiPath?: string, ejsPath?: string, apiVersion?: string, isCorsEnabled?: boolean, }
     ){
         this.publicPath = publicPath || "/incorrect-path-not-found";
         this.ejsPath = ejsPath || "/incorrect-ejs-path-not-found";
         this.apiPath = apiPath ?? "/api";
         this.apiVersion = apiVersion ?? null;
-        this.isCorsEnabled = isCorsEnabled ?? false;
         
         this.actionList = [];
         this.hookList = {
@@ -120,6 +113,24 @@ export default class Lambder {
         this.utils = new LambderUtils({ ejsPath });
     }
 
+    enableCORS(isCorsEnabled: boolean){
+        this.isCorsEnabled = isCorsEnabled;
+    }
+
+    enableDdbSession(
+        { tableName, tableRegion, sessionSalt }: { tableName: string; tableRegion: string; sessionSalt: string; }, 
+        { partitionKey, sortKey }: { partitionKey: string, sortKey: string } = { partitionKey: "pk", sortKey: "sk" }
+    ){
+        this.lambderSession = new LambderSession({
+            tableName, tableRegion, partitionKey, sortKey, sessionSalt
+        });
+    }
+
+    setSessionCookieKey(sessionTokenCookieKey: string, sessionCsrfCookieKey: string){
+        this.sessionTokenCookieKey = sessionTokenCookieKey;
+        this.sessionCsrfCookieKey = sessionCsrfCookieKey;
+    }
+
     setRouteFallbackHandler(routeFallbackHandler: RouteFallbackHandlerFunction){
         this.routeFallbackHandler = routeFallbackHandler;
     }
@@ -138,20 +149,26 @@ export default class Lambder {
         return (match(pattern, { decode: decodeURIComponent }))(path) !== false;
     }
 
-    private async validateSession (ctx: LambderRenderContext): Promise<boolean>{
-        const { session, apiName, post, cookie } = ctx;
-        if(!session) return false;
-        if(!session.userId || !session.userIdHash || !session.sessionHash || !session.csrfToken) return false;
-        if(!session.createdTimeStamp || !session.expiresTimeStamp) return false;
-        if(session.expiresTimeStamp > Date.now()) return false;
-
-        if(apiName){
-            if(!post.token) return false;
-            if(post.token !== cookie.LMBDRTOKEN) return false;
-            if(post.token !== session.csrfToken) return false;
-        }
-        // Check DDB;
-        return 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){
@@ -210,7 +227,8 @@ export default class Lambder {
                 )
             ), 
             actionFn: async (ctx:LambderRenderContext, resolver: LambderResolver) => {
-                const isSessionValid = this.validateSession(ctx);
+                await this.fetchSession(ctx);
+                const isSessionValid = this.validateSessionForRoute(ctx);
                 if(!isSessionValid) throw new Error("Session not found");
                 if(typeof condition === "string"){
                     ctx.pathParams = this.getPatternMatch(condition, ctx.path);
@@ -245,7 +263,8 @@ export default class Lambder {
                 )
             ), 
             actionFn: async (ctx:LambderRenderContext, resolver: LambderResolver) => {
-                const isSessionValid = this.validateSession(ctx);
+                await this.fetchSession(ctx);
+                const isSessionValid = this.validateSessionForAPI(ctx);
                 if(!isSessionValid) throw new Error("Session not found");
                 return await actionFn(ctx, resolver);
             }

package/src/LambderCaller.ts

@@ -81,7 +81,7 @@ export default class LambderCaller {
 
     };
 
-    async apiRaw<T>(apiName: string, payload?: any, options?: {
+    async apiRaw<T=any>(apiName: string, payload?: any, options?: {
         headers?: Record<string, any>
         versionExpiredHandler?: VoidFunction, 
         sessionExpiredHandler?: VoidFunction, 
@@ -91,7 +91,7 @@ export default class LambderCaller {
         errorHandler?: ErrorHandler, 
         fetchStartedHandler?: FetchStartEventHandler, 
         fetchEndedHandler?: FetchEndEventHandler,
-    }): Promise<LambderApiResponse<T>|null>{
+    }): Promise<LambderApiResponse<T>|null|undefined>{
         const headers = options?.headers;
         const fetchTracker: FetchTracker = { apiName, done: false, fetchEndCalled: false };
         try {
@@ -170,10 +170,9 @@ export default class LambderCaller {
     };
     
     // Use the same type for api but adjust the return type
-    async api<T>(...params: Parameters<typeof LambderCaller.prototype.apiRaw>): Promise<T|null> {
+    async api<T=any>(...params: Parameters<typeof LambderCaller.prototype.apiRaw>): Promise<T|null|undefined> {
         const result = await this.apiRaw<T>(...params);
-        if (!result) return null;
-        return result.payload ?? null;
+        return result?.payload;
     }
 
 }

package/src/LambderSession.ts

@@ -0,0 +1,166 @@
+import crypto from "crypto";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, QueryCommand, DeleteCommand, PutCommand, GetCommand } from "@aws-sdk/lib-dynamodb";
+
+export type LambderSessionContext = {
+    [x: string]: any;
+    sessionToken: string;
+    csrfToken: string;
+    userKey: string;
+    data: any;
+    createdAt: number;
+    expiresAt: number;
+    ttlInSeconds: number;
+};
+
+
+export default class LambderSession{
+    private tableName: string;
+    private sessionSalt: string;
+    private partitionKey: string;
+    private sortKey: string;
+    private ddbDocumentClient: DynamoDBDocumentClient;
+
+    constructor(
+        {
+            tableName, tableRegion,
+            partitionKey, sortKey,
+            sessionSalt,
+        }: {
+            tableName: string, tableRegion: string,
+            partitionKey: string, sortKey: string,
+            sessionSalt: string,
+        }
+    ){
+        this.tableName = tableName;
+        this.sessionSalt = sessionSalt;
+        this.partitionKey = partitionKey;
+        this.sortKey = sortKey;
+
+        const ddbClient = new DynamoDBClient({ region: tableRegion });
+        this.ddbDocumentClient = DynamoDBDocumentClient.from(ddbClient);
+    }
+
+    private sessionUserKeyHasher(password:string){
+        return crypto.createHash("sha256")
+                     .update(`${password}${this.sessionSalt}`)
+                     .digest("hex");
+    }
+
+    private async ddbGetItem<T=any>(key:Record<string,string|number>){
+        const response = await this.ddbDocumentClient.send(
+            new GetCommand({ TableName: this.tableName, Key: key, ConsistentRead: true })
+        );
+        if(response.Item) return response.Item as T;
+        return null;
+    };
+    private async ddbPutItem(item: Record<string,any>){
+        return await this.ddbDocumentClient.send(
+            new PutCommand({ TableName: this.tableName, Item: item, })
+        );
+    };
+
+    private async ddbDeleteItem(key:Record<string,string|number>){
+        return await this.ddbDocumentClient.send(
+            new DeleteCommand({ TableName: this.tableName, Key: key, })
+        );
+    };
+
+    private async ddbQueryAllByPartitionKey (partitionValue: string){
+        const params: any = {
+            TableName: this.tableName,
+            KeyConditionExpression: "#pk = :pv",
+            ExpressionAttributeNames:{ "#pk": this.partitionKey },
+            ExpressionAttributeValues: { ":pv": partitionValue },
+        }
+        const queryResults: any[] = [];
+        do{
+            const {Items, LastEvaluatedKey} =  await this.ddbDocumentClient.send(new QueryCommand(params));
+            if(Items) queryResults.push(...Items);
+            params.ExclusiveStartKey  = LastEvaluatedKey;
+            if(typeof LastEvaluatedKey == "undefined") return queryResults;
+        // eslint-disable-next-line no-constant-condition
+        } while (true);
+    };
+
+    private async ddbDeleteAllByPartitionKey(partitionValue: string){
+        const queryResults = await this.ddbQueryAllByPartitionKey(partitionValue);
+        for(const item of queryResults){
+            await this.ddbDocumentClient.send(new DeleteCommand({
+                TableName: this.tableName,
+                Key: { [this.partitionKey]: partitionValue, [this.sortKey]: item[this.sortKey] }
+            }));
+        }
+    }
+
+    public async createSession(
+        userKey: string, 
+        data: any = {}, 
+        ttlInSeconds:number = 30*24*60*60
+    ): Promise<LambderSessionContext> {
+        const userKeyHash = this.sessionUserKeyHasher(userKey);
+        const sessionSortKey = crypto.randomBytes(32).toString("hex");
+        const sessionToken = `${userKeyHash}:${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.sortKey]: sessionSortKey,
+            sessionToken, csrfToken,
+            userKey, data, 
+            createdAt, expiresAt, ttlInSeconds
+        };
+        await this.ddbPutItem(session);
+        return session;
+    }
+
+    public async getSession(sessionToken: string): Promise<LambderSessionContext|null>{
+        const [ userKeyHash, sessionSortKey ] = sessionToken.split(":");
+        if(!userKeyHash || !sessionSortKey) return null;
+        try{
+            let session = await this.ddbGetItem({ 
+                [this.partitionKey]: userKeyHash, 
+                [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";
+            return session;
+        }catch(err){
+            return null;
+        }
+    };
+
+    public isSessionValid(session: any, sessionToken: any, csrfToken: any, skipCsrfTokenCheck = false){
+        if(!session) return false;
+        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.createdAt) return false;
+        if(!session.expiresAt || session.expiresAt < Date.now()/1000) return false;
+        if(!skipCsrfTokenCheck){
+            if(!csrfToken || typeof csrfToken !== "string") return false;
+            if(session.csrfToken !== csrfToken) return false;
+        }
+        return true;
+    }
+
+    public async deleteSession(session: Record<string, any>): Promise<boolean>{
+        await this.ddbDeleteItem({ 
+            [this.partitionKey]: session[this.partitionKey],
+            [this.sortKey]: session[this.sortKey],
+        });
+        return true;
+    };
+
+    public async deleteSessionAll (session: Record<string, any>): Promise<boolean>{
+        await this.ddbDeleteAllByPartitionKey(session[this.partitionKey])
+        return true;
+    };
+};