aws-classify-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Sam Elsamman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,306 @@
+# aws-classify
+
+A library for calling AWS lambda functions from a browser or react-native app where the lambda functions are implemented as Typescript class members.  You create a request and corresponding response class. When you call the request class member function aws-classify takes care of the magic of invoking the corresponding response class member as a Lambda function. 
+
+The reverse is also true in that class members implemented in the browser can be called from within a Lambda server. The latter uses Web Sockets in the AWS gateway. aws-classify also provides for a static website from which everything can be executed to comply with same-origin policy.  
+
+* Complex data with classes and cyclic structures can be passed and returned
+* Execptions are passed back to the caller of the request method
+* back-end session data is simply a matter of defining fields in the response class
+* Configuration and deployment via a simple serverless.yml file
+
+### AWS Resources Configured and Deployed
+These AWS resources are automatically configured and deployment is fully automated:
+* AWS Lambda
+* Web Sockets in the AWS Gateway
+* Dynamo DB for managing sessions
+* S3 for a static website
+* Cloudfront with a custom domain name as a CDN
+
+All of these resources are configured by the Serverless Framework and deployed by running a script.  You only need to login to AWS in order toc reate credentials for the Serverless Framework and to register your domain name and create an SSL certificate.  
+
+### Use Cases
+aws-classify harnesses AWS to make it easy to leverage a scalable cloud-based infrastructure with virtually no learning curve.  From there you can leverage all of the other AWS resources your application may need.  The primary use-case is startups and projects that want a complete "app in a box" solution.
+ 
+## Installation
+
+On the project that implements the lambda functions
+
+```npm install aws-classify-common, aws-classify-server```
+
+
+On the client project
+
+
+```npm install aws-classify-common, aws-classify-client```
+
+The framework has been tested with popular client software such as Expo for mobile and React Native for web.
+
+## Calling Lambda Functions from the Client
+
+### Create a Request/Response Pair of Classes
+
+Create a request class that you will instantiate on the client:
+
+```typescript
+export class ServerRequest {
+    static interfaceName = 'ServerRequest';
+    async setCount (count : number) { reqBody() }
+    async getCount () : Promise<number> { return reqBody() }
+}
+```
+Create a corresponding response class that extends the request class:
+```typescript
+export class ServerResponse extends ServerRequest {
+    count = 0;
+    async setCount(count: number) {this.count = count}
+    async getCount(): Promise<number> {return this.count}
+}
+```
+Once these classes are registered and instantiated using aws-classify you simply call the request method and the response method is executed as a Lambda function.  Any fields (e.g. count) in the response class are saved and restored between calls and serve as session data.  Request classes must have a unique static interface name field so they are uniquely identified.
+
+### Using the Request Class
+
+You instantiate the request class and invoke its methods like this on the client:
+```typescript
+    const classifyClient = new ClassifyClient(getSession, saveSession);
+    serverRequest = classifyClient.createRequest(ServerRequest);
+    await serverRequest.setCount(2023);
+```   
+Since aws-classify is client platform-agnostic you need to implement getSession and saveSession for persisting client session data.  In the browser it would look like this:
+```typescript
+    async function getSession () {
+        return localStorage.getItem('ClassifySession') || "None"
+    }
+    async function setSession(sessionId : string) {
+        localStorage.setItem('ClassifySession', sessionId);
+    }
+```
+If the implementation on the response class throws an Error, the Error will be thrown when you call the request class so it is best to enclose the call in a try/catch:
+```typescript
+    try {
+       await serverRequest.setCount(2023);
+    } catch (e) { console.log(e) }    
+```
+### Using the Response class
+You must register the class so it can be instantiated when the client calls. Usually this is done in the file where the class is defined: 
+```typescript
+    classifyServerless.registerRespon(ServerResponse)
+ ```
+Because class fields are persisted between calls from the same session, you need to declare the response class as serializable so that js-freezedry can serialize it. Usually this is done in the file where the class is defined:
+```
+    serializable(ServerResponse)
+```
+## Calling Client Functions from Lambda Functions
+Calling member functions implemented on the client use WebSockets.  There are three distinct use cases:
+* ***Same Session*** - Call a client-request for the same session as the caller of your Lambda function.  
+* ***Alternate Session*** - Instantiate a response class for a different session and then call a client request for that session.  This allows means the response class for the alternate session can change it's session session data
+* ***Direct to Alternate Session*** A shortcut whereby the Lambda fuction directly invokes a request method for an alternate session.
+
+### Setup Requests and Response Classes
+Your Lambda functions can also call requests that will be implemented in the browser.  The class setup is analogous in that you define a request class
+```typescript
+export class ClientRequest {
+    static interfaceName = 'ClientRequest';
+    setCount(count : number) {reqBody()}
+}
+```
+and a response class
+```typescript
+export class ClientResponse extends ClientRequest{
+    count = 0;
+    setCount(count: number) {
+        this.count = 0;
+        console.log(count);
+    }
+}
+```
+On the client you need to instantiate the response class like this:
+```typescript
+    const classifyClient = new ClassifyClient(getSession, saveSession);
+    const clientResponse = classifyClient.createResponse(ClientResponse);
+```
+
+### Implement Lambda Response methods
+In all cases you must register the request class. 
+```typescript
+classifyServerless.registerRequest(ClientRequest);
+```
+For the ***Same Session*** case you instantiate the request object and call the method. The first parameter of **createRequest** is a response object from which the session is to be extracted:
+```typescript
+export class ServerResponse extends ServerRequest {
+    count = 0;
+    // ....
+    async sendCount() {
+        const clientRequest = classifyServerless.createRequest(this, ClientRequest);
+        clientRequest.setCount(this.count);
+    }
+}
+```
+For the ***Alternate Session*** case you first instantiate a response object for the target session and call a method that will invoke a request for the target session:
+```typescript
+ export class ServerResponse extends ServerRequest {
+    count = 0;
+    // ...
+    async sendCountTo(sessionId: string) {
+        await classifyServerless.createResponse(ServerResponse, sessionId, async serverResponse => {
+            await serverResponse.sendCount()
+        });
+    }
+    async sendCount() {
+        const clientRequest = classifyServerless.createRequest(this, ClientRequest);
+        clientRequest.setCount(this.count);
+    }
+    
+}
+```
+
+And for the ***Direct to Alternate Session*** case you may directly instantiate a request object for the target session and invoke its method
+```typescript
+export class ServerResponse extends ServerRequest {
+    count = 0;
+    // ...
+    async sendOurCountTo(sessionId: string) {
+        const clientRequest = await classifyServerless.createRequestForSession(sessionId, ClientRequest);
+        await clientRequest.setCount(this.count);
+    }
+}
+```
+The combination of these use cases allows for a rich set of interactions between code in the cloud and code on the server.  For example:
+* You have two sessions "chat" with other by sharing the session Id
+* You can instantiate and invoke your class methods from any normal Lambda function provided that you have a session.  This includes any of the AWS event mechanisms capable of invoking Lamda functions 
+## Project Structure
+The mono repo structure is ideal for projects that use aws-classify as you typically will have a server sub-project and one or more client projects, perhaps mobile and web.  These projects will share code as the request classes must be present in both the client and the server.  The easiest way to accomplish this is using bisync which synchronizes your shared directories automatically.
+
+```
+Root
+- bisync.json (configured to synchronized shared directories)
+- package.json (just for bisync)
+- node_modules (just bisync)
+- cloud
+  - serverless.yml
+  - server-requests (contains request classes implemented on the server)
+  - server-responses (contains implementations on server)
+  - client-requests (contains request classes implented on the client)
+- web (could be a project created with create-react-app)
+  - server-requests (contains request classes implemented on the server) 
+  - client-requests (contains request classes implented on the client)
+  - client-responses (contains implementation on client)
+  - other files pertaining to the client and static website   
+```
+You would then configure bisync.json to keep the shared code in sync
+```
+[
+    ["./cloud/client-requests", "./web/client-requests"],
+    ["./clout/server-requests", "./web/server-requests"]
+]    
+```
+Implementing shared code this way avoid restrictions that packaging schemes have that effectively require code to be present in project tree
+## Deployment
+This serverless.yml file is all you need to configure AWS:
+```
+service: 'aws-classify-tests'
+
+custom:
+
+  #
+  # You need to fill these out
+  #
+
+  # Specify this even if you don't have a custom domain at this time
+  domain: awsclassify.com
+  # Get your AWS SSL Certificate and put it here if you have a custom domain
+  certificateARN: "arn:aws:acm:us-east-1:############:certificate/########-####-####-####-############"
+
+  # Map stages to domain prefixes
+  prefixes:
+    dev: test.
+    prod: ''
+
+  directories:
+    responseHandlers: "src/server-responses/index"
+    staticWebsite: "./static"
+    includeFiles: "node_modules/aws-classify/yml"
+
+  #Include any scripts needed to build your static site
+  #scripts:
+    #hooks:
+    #'before:deploy:deploy': npm run build:static
+
+  #
+  # Boiler plate
+  #
+  yml: "../../yml/"
+  #yml ${self:custom.directories.includeFiles}
+  stage: ${opt:stage,'dev'}
+  hostedZoneName: ${self:custom.domain}.
+  domainName: ${self:custom.prefixes.${self:custom.stage}}{$self:custome.domain}
+  handler: "src/server-responses/index"
+  bucketName: ${self:custom.domainName}
+  s3Sync:
+    noSync: true
+    buckets:
+    - bucketName: ${self:custom.bucketName}
+      localDir: ${self:custom.directories.includeFiles}
+  cloudfrontInvalidate: ${file(${self:custom.yml}/custom-cloudfront.yml)}
+  serverless-offline:
+    httpPort: 4000
+  dynamodb: ${file(${self:custom.yml}/custom-dynamodb.yml)}
+
+
+plugins:
+  - serverless-plugin-scripts
+  - serverless-s3-sync
+  - serverless-cloudfront-invalidate
+  - serverless-plugin-typescript
+  - serverless-dynamodb-local
+  - serverless-offline
+
+provider:
+  name: aws
+  runtime: nodejs16.x
+  region: us-east-1
+  websocketsApiRouteSelectionExpression: $request.body.action
+  logs:
+    websocket: true
+  environment:
+    APIG_ENDPOINT: ${file(${self:custom.yml}/apig.yml)}
+  iam:
+    role:
+      - statements:
+        - ${file(${self:custom.yml}/provider-iam.yml)}
+
+functions:
+  - ${file(${self:custom.yml}/functions.yml)}
+
+resources:
+  - ${file(${self:custom.yml}/resources-website.yml)}
+  #  {file(${self:custom.yml}/resources-custom-website.yml)} if you have a custom domain
+
+```
+
+To deploy you need to:
+- Create AWS credentials using the AWS console as defined in the Serverless [documents](https://www.serverless.com/framework/docs/providers/aws/guide/credentials/documentation)
+- Install and setup credentials You need to setup your credentials with serverless
+```	
+serverless config credentials \
+  --provider aws \
+  --key AKIAIOSFODNN7EXAMPLE \
+  --secret wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+```
+- Obtain a no-cost SSL certificate on the AWS console and put it in the serverless.yml file
+- You can deploy a test version with
+```
+serverless deploy stage dev 
+```
+and a production version with 
+```
+serverless deploy stage prod 
+```
+
+## Roadmap
+* Create some sample applications
+* Continued shakeout with real-world applications
+* Community feedback
+
+At present the library should rightly be considered "beta" until it is more widely adopted.  It is ideal for side projects and proof of concepts.  It is also a useful reference on how to configure AWS services.

package/lib/cjs/ClassDef.d.ts

@@ -0,0 +1,6 @@
+import { ClassifyResponse } from "./ClassifyResponse";
+export interface ClassDef<ServerClass extends ClassifyResponse, ClientClass> {
+    serverClass: new () => ServerClass;
+    clientClass: new () => ClientClass;
+    authorizer: ((endPoint: ServerClass, method: string, args: IArguments) => Promise<boolean>) | undefined;
+}

package/lib/cjs/ClassDef.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/ClassifyResponse.d.ts

@@ -0,0 +1,6 @@
+export declare class ClassifyResponse {
+    __sessionId__: string | undefined;
+    __connectionId__: string | undefined;
+    __interfaceName__: string | undefined;
+    constructor(interfaceName: string, sessionId: string, connectionId: string);
+}

package/lib/cjs/ClassifyResponse.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassifyResponse = void 0;
+class ClassifyResponse {
+    constructor(interfaceName, sessionId, connectionId) {
+        this.__connectionId__ = connectionId;
+        this.__sessionId__ = sessionId;
+        this.__interfaceName__ = interfaceName;
+    }
+}
+exports.ClassifyResponse = ClassifyResponse;

package/lib/cjs/ClassifyServerless.d.ts

@@ -0,0 +1,27 @@
+import { ClassDef } from "./ClassDef";
+import { APIGatewayProxyEvent, Context } from "aws-lambda";
+export declare class ClassifyServerless {
+    logLevel: Partial<typeof EndPointsLogging>;
+    classDefs: Map<any, ClassDef<any, any>>;
+    requests: Map<any, any>;
+    log: (_message: string) => void;
+    setLogger(log: (_message: string) => void): void;
+    setLogLevel(logLevel: Partial<typeof EndPointsLogging>): void;
+    registerResponse<T>(responseClass: new () => T, authorizer?: (_endPoint: T, _method: string, _args: IArguments) => Promise<boolean>): void;
+    dispatch(ev: APIGatewayProxyEvent, context: Context, classes?: {}): Promise<string>;
+    registerRequest<T>(requestClass: new () => T, classes?: any): new () => T;
+    getSessionId<T>(responseObj: T): any;
+    createRequest<T, U>(responseObj: U, requestClass: new () => T): T;
+    createRequestForSession<T>(sessionId: string, requestClass: new () => T): Promise<T>;
+    createResponse<T, R>(responseClass: new () => T, sessionId: string, callback: (_obj: T) => Promise<R>, classes?: any): Promise<R>;
+}
+export declare function getSessionData(sessionId: string, interfaceName?: string): Promise<Record<string, any> | undefined>;
+export declare function saveSessionData(sessionId: string, interfaceName?: string, sessionData?: string, connectionId?: string): Promise<string>;
+export declare const EndPointsLogging: {
+    create: boolean;
+    connect: boolean;
+    exceptions: boolean;
+    calls: boolean;
+    requests: boolean;
+    data: boolean;
+};

package/lib/cjs/ClassifyServerless.js

@@ -0,0 +1,288 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndPointsLogging = exports.saveSessionData = exports.getSessionData = exports.ClassifyServerless = void 0;
+const js_freeze_dry_1 = require("js-freeze-dry");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const client_apigatewaymanagementapi_1 = require("@aws-sdk/client-apigatewaymanagementapi");
+const ddbClient = new client_dynamodb_1.DynamoDBClient({ region: process.env.DD_REGION, endpoint: process.env.DD_ENDPOINT });
+const ddbDocClient = lib_dynamodb_1.DynamoDBDocument.from(ddbClient);
+class ClassifyServerless {
+    constructor() {
+        this.logLevel = {};
+        this.classDefs = new Map();
+        this.requests = new Map();
+        this.log = msg => console.log(msg);
+    }
+    setLogger(log) {
+        this.log = log;
+    }
+    setLogLevel(logLevel) {
+        this.logLevel = logLevel;
+    }
+    registerResponse(responseClass, authorizer) {
+        // Find ultimate base class
+        let clientClass = responseClass;
+        while (Object.getPrototypeOf(clientClass).prototype)
+            clientClass = Object.getPrototypeOf(clientClass);
+        if (clientClass === responseClass)
+            throw ('ClassifyServerless.registerResponse: Response class must extend a request class');
+        // Get interface name as static property of request class
+        const interfaceName = clientClass['interfaceName'];
+        if (!interfaceName)
+            throw ('ClassifyServerless.registerResponse: Request must have interfaceName as a static property');
+        this.classDefs.set(interfaceName, { serverClass: responseClass, clientClass, authorizer });
+        responseClass.__interfaceName__ = interfaceName;
+    }
+    dispatch(ev, context, classes = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = (0, js_freeze_dry_1.deserialize)(ev.body, classes);
+            const logName = `${request.interfaceName}.${request.methodName}`;
+            let sessionId = request.sessionId; //  May be empty
+            // Pseudo interface/method to request socket access and return a session id to use in connect
+            // session id will be passed in sec-websocket-protocol on connect request
+            if (logName === '$WebSocket.$authorize') {
+                const socketResult = yield getSessionData(sessionId, "");
+                if (!socketResult) {
+                    sessionId = context.awsRequestId;
+                    yield saveSessionData(sessionId, undefined, undefined, undefined);
+                }
+                const lambdaResponse = {
+                    data: process.env.IS_OFFLINE ? 'ws://localhost:3001' : `wss://${process.env.APIG_ENDPOINT}`,
+                    exception: undefined,
+                    cargo: undefined,
+                    sessionId: sessionId,
+                };
+                return (0, js_freeze_dry_1.serialize)(lambdaResponse, classes);
+            }
+            if (this.logLevel.data && this.logLevel.calls)
+                this.log(`Lambda ${logName} invoked with ${ev.body}`);
+            else if (this.logLevel.calls)
+                this.log(`Lambda ${logName} invoked`);
+            const classDef = this.classDefs.get(request.interfaceName);
+            if (!classDef)
+                throw new Error(`No Response defined for ${request.interfaceName}`);
+            if (!classDef.clientClass.prototype[request.methodName])
+                throw new Error(`${request.methodName} not found in ${request.interfaceName} client request class`);
+            // If authorizer passed in make sure request is authorized
+            if (!classDef.authorizer || (yield classDef.authorizer(request.interfaceName, request.methodName, request.args))) {
+                // Instantiate the class
+                const obj = new classDef.serverClass();
+                // Retrieve session data from DynamoDB base on sessionId in request
+                const result = yield getSessionData(sessionId, request.interfaceName);
+                if (!result)
+                    sessionId = context.awsRequestId;
+                else {
+                    const sessionData = result[`interface_${request.interfaceName}`];
+                    if (sessionData) // Enrich it with session data
+                        Object.assign(obj, (0, js_freeze_dry_1.deserialize)(sessionData, classes));
+                }
+                obj.__sessionId__ = sessionId;
+                obj.__connectionId__ = result === null || result === void 0 ? void 0 : result.connectionId;
+                // Call the class method and catch any exceptions it might throw to pass back
+                let fnResponse;
+                try {
+                    fnResponse = yield obj[request.methodName].call(obj, ...request.args);
+                }
+                catch (e) {
+                    if (this.logLevel.calls)
+                        this.log(`Lambda ${logName} had exception ${e}`);
+                    const lambdaResponse = {
+                        data: undefined,
+                        exception: e.message,
+                        cargo: undefined,
+                        sessionId: sessionId,
+                    };
+                    return (0, js_freeze_dry_1.serialize)(lambdaResponse, classes);
+                }
+                const updatedSessionData = (0, js_freeze_dry_1.serialize)(obj, classes);
+                if (!result || updatedSessionData !== result.sessionData)
+                    sessionId = yield saveSessionData(sessionId, request.interfaceName, updatedSessionData, undefined);
+                // Formulate response
+                const lambdaResponse = {
+                    data: fnResponse,
+                    exception: undefined,
+                    cargo: undefined,
+                    sessionId,
+                };
+                const response = (0, js_freeze_dry_1.serialize)(lambdaResponse, classes);
+                if (this.logLevel.data && this.logLevel.calls)
+                    this.log(`Lambda ${logName} responded with ${response}`);
+                else if (this.logLevel.calls)
+                    this.log(`Lambda ${logName} responded`);
+                return response;
+            }
+            else {
+                this.log(`Lambda ${logName} not authorized`);
+                throw new Error("Not Authorized");
+            }
+        });
+    }
+    registerRequest(requestClass, classes = {}) {
+        const interfaceName = requestClass['interfaceName'];
+        if (!interfaceName)
+            throw ('ClassifyServerless.registerRequest: Request must have interfaceName as a static property');
+        for (const methodName of Object.getOwnPropertyNames(requestClass.prototype)) {
+            if (methodName === 'constructor' || typeof (requestClass.prototype)[methodName] !== 'function')
+                continue;
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const expressServer = this;
+            requestClass.prototype[methodName] = function (...args) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // Build request
+                        const sessionId = this['__sessionId__'];
+                        const connectionId = this['__connectionId__'];
+                        if (!sessionId)
+                            throw new Error(`You must instantiate ${interfaceName} using the ClassifyServerless.createRequest`);
+                        if (!connectionId)
+                            throw new Error(`WebSocket handshake not established for ${interfaceName}`);
+                        const request = {
+                            interfaceName: interfaceName,
+                            args, methodName,
+                            sessionId
+                        };
+                        const payload = (0, js_freeze_dry_1.serialize)(request, classes);
+                        // Log request
+                        if (expressServer.logLevel.data && expressServer.logLevel.requests)
+                            expressServer.log(`Request ${interfaceName} emitting with ${payload}`);
+                        else if (expressServer.logLevel && expressServer.logLevel.requests)
+                            expressServer.log(`Request ${interfaceName} emitting`);
+                        // Post request to the gateway to be sent to src
+                        const endpoint = process.env.IS_OFFLINE ? 'http://localhost:3001' : `https://${process.env.APIG_ENDPOINT}`;
+                        if (expressServer.logLevel.calls)
+                            expressServer.log(`creating APIGatewayManagementApiClient for endpoint ${endpoint}`);
+                        const client = new client_apigatewaymanagementapi_1.ApiGatewayManagementApiClient({ endpoint });
+                        if (expressServer.logLevel.data)
+                            expressServer.log(`posting to ${connectionId} ${payload}`);
+                        const post = new client_apigatewaymanagementapi_1.PostToConnectionCommand({
+                            ConnectionId: connectionId,
+                            Data: Buffer.from(payload)
+                        });
+                        yield client.send(post);
+                        // Catch any exception, so it can be logged and then rethrown
+                    }
+                    catch (e) {
+                        if (expressServer.logLevel.exceptions)
+                            expressServer.log(e.message);
+                        throw e;
+                    }
+                });
+            };
+            if (this.logLevel.create)
+                this.log(`${interfaceName} bound to ${requestClass.name}.${methodName}`);
+        }
+        return requestClass;
+    }
+    getSessionId(responseObj) {
+        const sessionId = responseObj['__sessionId__'];
+        if (!sessionId)
+            throw Error('ClassifyServerless.getSessionId: no session id');
+        return sessionId;
+    }
+    createRequest(responseObj, requestClass) {
+        const obj = new requestClass();
+        obj['__sessionId__'] = responseObj['__sessionId__'];
+        obj['__connectionId__'] = responseObj['__connectionId__'];
+        return obj;
+    }
+    createRequestForSession(sessionId, requestClass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get connection Id
+            const result = yield getSessionData(sessionId);
+            if (!result)
+                throw new Error(`ClassifyResponse.createRequestForSession: invalid session id`);
+            if (!result.connectionId)
+                throw new Error(`WebSocket handshake not established for session`);
+            // Create request
+            const obj = new requestClass();
+            obj['__sessionId__'] = sessionId;
+            obj['__connectionId__'] = result.connectionId;
+            return obj;
+        });
+    }
+    createResponse(responseClass, sessionId, callback, classes = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const interfaceName = responseClass.__interfaceName__;
+            if (!interfaceName)
+                throw new Error(`ClassifyResponse.createResponse: Failed to call registerResponse for ${responseClass.name}`);
+            const result = yield getSessionData(sessionId, interfaceName);
+            if (!result)
+                throw new Error(`ClassifyResponse.createResponse: invalid session id for interface ${interfaceName}`);
+            const sessionData = result[`interface_${interfaceName}`];
+            // Instantiate the class
+            const obj = (new responseClass());
+            // Enrich it with session data
+            if (sessionData)
+                Object.assign(obj, (0, js_freeze_dry_1.deserialize)(sessionData, classes));
+            obj.__sessionId__ = sessionId;
+            obj.__connectionId__ = result.connectionId;
+            if (this.logLevel.calls)
+                this.log(`creating response for ${interfaceName} with sessionId=${sessionId} connectionId= ${obj.__connectionId__} sessionData=${sessionData}`);
+            const ret = yield callback(obj);
+            const updatedSessionData = (0, js_freeze_dry_1.serialize)(obj, classes);
+            if (updatedSessionData !== result.sessionData) {
+                if (this.logLevel.calls)
+                    this.log(`saving session data for ${interfaceName} with sessionId=${sessionId} connectionId= ${obj.__connectionId__} sessionData=${updatedSessionData}`);
+                yield saveSessionData(sessionId, interfaceName, updatedSessionData, undefined);
+            }
+            return ret;
+        });
+    }
+}
+exports.ClassifyServerless = ClassifyServerless;
+function getSessionData(sessionId, interfaceName = "") {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (sessionId) {
+            const data = yield ddbDocClient.get({
+                TableName: 'classifySessionStore',
+                Key: { sessionId },
+                ConsistentRead: true,
+                ProjectionExpression: `interface_${interfaceName}, connectionId, updated`
+            });
+            return data.Item;
+        }
+        return undefined;
+    });
+}
+exports.getSessionData = getSessionData;
+function saveSessionData(sessionId, interfaceName, sessionData, connectionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const updateExpressionComponents = ['updated = :time'];
+        const expressionAttributeValues = { ':time': new Date().getTime() };
+        if (sessionData && interfaceName) {
+            updateExpressionComponents.push(`interface_${interfaceName} = :data`);
+            expressionAttributeValues[`:data`] = sessionData;
+        }
+        if (connectionId) {
+            updateExpressionComponents.push('connectionId = :connectionId');
+            expressionAttributeValues[':connectionId'] = connectionId;
+        }
+        // First try and out data only if the session id exists
+        yield ddbDocClient.update({
+            TableName: 'classifySessionStore',
+            Key: { sessionId },
+            UpdateExpression: `set ${updateExpressionComponents.join(", ")}`,
+            ExpressionAttributeValues: expressionAttributeValues
+        });
+        return sessionId;
+    });
+}
+exports.saveSessionData = saveSessionData;
+exports.EndPointsLogging = {
+    create: true,
+    connect: true,
+    exceptions: true,
+    calls: true,
+    requests: false,
+    data: false,
+};