aws-classify-server 0.1.0

package/lib/cjs/SessionData.d.ts

@@ -0,0 +1,6 @@
+import { ClassDef } from "./ClassDef";
+export interface SessionData {
+    classDef: ClassDef<any, any>;
+    cargo: any;
+    sessionId: any;
+}

package/lib/cjs/SessionData.js

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

package/lib/cjs/aws-classify-common/EndPointsLogging.d.ts

@@ -0,0 +1,8 @@
+export declare const EndPointsLogging: {
+    create: boolean;
+    connect: boolean;
+    exceptions: boolean;
+    calls: boolean;
+    requests: boolean;
+    data: boolean;
+};

package/lib/cjs/aws-classify-common/EndPointsLogging.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndPointsLogging = void 0;
+exports.EndPointsLogging = {
+    create: true,
+    connect: true,
+    exceptions: true,
+    calls: true,
+    requests: false,
+    data: false,
+};

package/lib/cjs/aws-classify-common/LambdaRequest.d.ts

@@ -0,0 +1,6 @@
+export interface LambdaRequest {
+    interfaceName: string;
+    methodName: string;
+    args: any;
+    sessionId: string;
+}

package/lib/cjs/aws-classify-common/LambdaRequest.js

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

package/lib/cjs/aws-classify-common/LambdaResponse.d.ts

@@ -0,0 +1,6 @@
+export interface LambdaResponse {
+    data: any;
+    cargo: any;
+    exception: string | undefined;
+    sessionId: string;
+}

package/lib/cjs/aws-classify-common/LambdaResponse.js

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

package/lib/cjs/aws-classify-common/index.d.ts

@@ -0,0 +1,4 @@
+export type { LambdaRequest } from './LambdaRequest';
+export type { LambdaResponse } from './LambdaResponse';
+export { EndPointsLogging } from './EndPointsLogging';
+export declare const reqBody: () => never;

package/lib/cjs/aws-classify-common/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reqBody = exports.EndPointsLogging = void 0;
+var EndPointsLogging_1 = require("./EndPointsLogging");
+Object.defineProperty(exports, "EndPointsLogging", { enumerable: true, get: function () { return EndPointsLogging_1.EndPointsLogging; } });
+const reqBody = () => { throw new Error('Request class not registered'); };
+exports.reqBody = reqBody;

package/lib/cjs/dispatch.d.ts

@@ -0,0 +1,7 @@
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import { ClassifyServerless } from "./index";
+import { APIGatewayProxyStructuredResultV2 } from "aws-lambda/trigger/api-gateway-proxy";
+export declare const classifyServerless: ClassifyServerless;
+export declare const responseHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyStructuredResultV2>;
+export declare const webSocketConnect: (event: APIGatewayProxyEvent, _context: Context) => Promise<APIGatewayProxyStructuredResultV2>;
+export declare const webSocketDisconnect: (_event: APIGatewayProxyEvent, _context: Context) => Promise<APIGatewayProxyStructuredResultV2>;

package/lib/cjs/dispatch.js

@@ -0,0 +1,79 @@
+"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.webSocketDisconnect = exports.webSocketConnect = exports.responseHandler = exports.classifyServerless = void 0;
+const index_1 = require("./index");
+const js_freeze_dry_1 = require("js-freeze-dry");
+const ClassifyServerless_1 = require("./ClassifyServerless");
+exports.classifyServerless = new index_1.ClassifyServerless();
+const responseHandler = (event, context) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        //console.log(`dispatching`);
+        return {
+            statusCode: 200,
+            body: (yield exports.classifyServerless.dispatch(event, context)) || "",
+        };
+    }
+    catch (err) {
+        //console.log(`request.body = ${event.body}`);
+        console.log(`error = ${err.message} ${err.stack}`);
+        return {
+            statusCode: 200,
+            body: (0, js_freeze_dry_1.serialize)({
+                data: undefined,
+                exception: `Internal Server Error (${err}) - see log at ${new Date()}`,
+                cargo: undefined,
+                sessionId: undefined
+            })
+        };
+    }
+});
+exports.responseHandler = responseHandler;
+const webSocketConnect = (event, _context) => __awaiter(void 0, void 0, void 0, function* () {
+    //console.log('connecting');
+    const sessionId = event.headers['Sec-WebSocket-Protocol'] || "";
+    const connectId = event.requestContext.connectionId;
+    //console.log(JSON.stringify(event));
+    const result = yield (0, ClassifyServerless_1.getSessionData)(sessionId); // Make sure session id passed in is valid
+    if (result) {
+        // Save connection id
+        yield (0, ClassifyServerless_1.saveSessionData)(sessionId, undefined, undefined, connectId);
+        //console.log(`webSocketConnect session ${sessionId} connected to websocket connectId ${connectId}`);
+        return {
+            statusCode: 200,
+            headers: {
+                'Sec-WebSocket-Protocol': sessionId
+            },
+            body: JSON.stringify({
+                msg: connectId,
+            })
+        };
+    }
+    else {
+        console.log(`invalid sessionId - webSocketConnect sessionId=${sessionId} connectId=${connectId}`);
+        return {
+            statusCode: 500,
+            body: 'Opps'
+        };
+    }
+});
+exports.webSocketConnect = webSocketConnect;
+const webSocketDisconnect = (_event, _context) => __awaiter(void 0, void 0, void 0, function* () {
+    //console.log('Disconnect ' + JSON.stringify(event));
+    //console.log(`webSocketDisconnect sessionId=${sessionId} connectId=${connectId}`);
+    return {
+        statusCode: 200,
+        headers: {
+            'Sec-WebSocket-Protocol': 'websocket'
+        }
+    };
+});
+exports.webSocketDisconnect = webSocketDisconnect;

package/lib/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export { ClassifyServerless } from './ClassifyServerless';
+export { ClassifyResponse } from './ClassifyResponse';
+export { classifyServerless, webSocketConnect, webSocketDisconnect, responseHandler } from './dispatch';

package/lib/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseHandler = exports.webSocketDisconnect = exports.webSocketConnect = exports.classifyServerless = exports.ClassifyResponse = exports.ClassifyServerless = void 0;
+var ClassifyServerless_1 = require("./ClassifyServerless");
+Object.defineProperty(exports, "ClassifyServerless", { enumerable: true, get: function () { return ClassifyServerless_1.ClassifyServerless; } });
+var ClassifyResponse_1 = require("./ClassifyResponse");
+Object.defineProperty(exports, "ClassifyResponse", { enumerable: true, get: function () { return ClassifyResponse_1.ClassifyResponse; } });
+var dispatch_1 = require("./dispatch");
+Object.defineProperty(exports, "classifyServerless", { enumerable: true, get: function () { return dispatch_1.classifyServerless; } });
+Object.defineProperty(exports, "webSocketConnect", { enumerable: true, get: function () { return dispatch_1.webSocketConnect; } });
+Object.defineProperty(exports, "webSocketDisconnect", { enumerable: true, get: function () { return dispatch_1.webSocketDisconnect; } });
+Object.defineProperty(exports, "responseHandler", { enumerable: true, get: function () { return dispatch_1.responseHandler; } });

package/lib/esm/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/esm/ClassDef.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/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/esm/ClassifyResponse.js

@@ -0,0 +1,7 @@
+export class ClassifyResponse {
+    constructor(interfaceName, sessionId, connectionId) {
+        this.__connectionId__ = connectionId;
+        this.__sessionId__ = sessionId;
+        this.__interfaceName__ = interfaceName;
+    }
+}

package/lib/esm/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/esm/ClassifyServerless.js

@@ -0,0 +1,282 @@
+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());
+    });
+};
+import { deserialize, serialize } from "js-freeze-dry";
+import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { ApiGatewayManagementApiClient, PostToConnectionCommand } from "@aws-sdk/client-apigatewaymanagementapi";
+const ddbClient = new DynamoDBClient({ region: process.env.DD_REGION, endpoint: process.env.DD_ENDPOINT });
+const ddbDocClient = DynamoDBDocument.from(ddbClient);
+export 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 = 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 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, 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 serialize(lambdaResponse, classes);
+                }
+                const updatedSessionData = 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 = 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 = 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 ApiGatewayManagementApiClient({ endpoint });
+                        if (expressServer.logLevel.data)
+                            expressServer.log(`posting to ${connectionId} ${payload}`);
+                        const post = new 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, 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 = 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;
+        });
+    }
+}
+export 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;
+    });
+}
+export 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;
+    });
+}
+export const EndPointsLogging = {
+    create: true,
+    connect: true,
+    exceptions: true,
+    calls: true,
+    requests: false,
+    data: false,
+};

package/lib/esm/SessionData.d.ts

@@ -0,0 +1,6 @@
+import { ClassDef } from "./ClassDef";
+export interface SessionData {
+    classDef: ClassDef<any, any>;
+    cargo: any;
+    sessionId: any;
+}

package/lib/esm/SessionData.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/aws-classify-common/EndPointsLogging.d.ts

@@ -0,0 +1,8 @@
+export declare const EndPointsLogging: {
+    create: boolean;
+    connect: boolean;
+    exceptions: boolean;
+    calls: boolean;
+    requests: boolean;
+    data: boolean;
+};

package/lib/esm/aws-classify-common/EndPointsLogging.js

@@ -0,0 +1,8 @@
+export const EndPointsLogging = {
+    create: true,
+    connect: true,
+    exceptions: true,
+    calls: true,
+    requests: false,
+    data: false,
+};

package/lib/esm/aws-classify-common/LambdaRequest.d.ts

@@ -0,0 +1,6 @@
+export interface LambdaRequest {
+    interfaceName: string;
+    methodName: string;
+    args: any;
+    sessionId: string;
+}

package/lib/esm/aws-classify-common/LambdaRequest.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/aws-classify-common/LambdaResponse.d.ts

@@ -0,0 +1,6 @@
+export interface LambdaResponse {
+    data: any;
+    cargo: any;
+    exception: string | undefined;
+    sessionId: string;
+}

package/lib/esm/aws-classify-common/LambdaResponse.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/aws-classify-common/index.d.ts

@@ -0,0 +1,4 @@
+export type { LambdaRequest } from './LambdaRequest';
+export type { LambdaResponse } from './LambdaResponse';
+export { EndPointsLogging } from './EndPointsLogging';
+export declare const reqBody: () => never;

package/lib/esm/aws-classify-common/index.js

@@ -0,0 +1,2 @@
+export { EndPointsLogging } from './EndPointsLogging';
+export const reqBody = () => { throw new Error('Request class not registered'); };

package/lib/esm/dispatch.d.ts

@@ -0,0 +1,7 @@
+import { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import { ClassifyServerless } from "./index";
+import { APIGatewayProxyStructuredResultV2 } from "aws-lambda/trigger/api-gateway-proxy";
+export declare const classifyServerless: ClassifyServerless;
+export declare const responseHandler: (event: APIGatewayProxyEvent, context: Context) => Promise<APIGatewayProxyStructuredResultV2>;
+export declare const webSocketConnect: (event: APIGatewayProxyEvent, _context: Context) => Promise<APIGatewayProxyStructuredResultV2>;
+export declare const webSocketDisconnect: (_event: APIGatewayProxyEvent, _context: Context) => Promise<APIGatewayProxyStructuredResultV2>;