somod-chat-service 0.8.2 → 1.0.0

package/build/lib/cache.js

@@ -1,34 +1,32 @@
-import { __awaiter, __generator } from "tslib";
-export var cache = function (max, ttl) {
-    var cacheTtl = ttl;
-    var nodes = {};
-    var first = undefined;
-    var last = undefined;
-    var size = 0;
-    var remove = function (key) {
-        var _a, _b;
-        var node = nodes[key];
+export const cache = (max, ttl) => {
+    const cacheTtl = ttl;
+    const nodes = {};
+    let first = undefined;
+    let last = undefined;
+    let size = 0;
+    const remove = (key) => {
+        const node = nodes[key];
         if (node.next) {
             node.next.previous = node.previous;
         }
         else {
-            last = (_a = node.previous) === null || _a === void 0 ? void 0 : _a.content.key;
+            last = node.previous?.content.key;
         }
         if (node.previous) {
             node.previous.next = node.next;
         }
         else {
-            first = (_b = node.next) === null || _b === void 0 ? void 0 : _b.content.key;
+            first = node.next?.content.key;
         }
         size--;
         delete nodes[key];
     };
-    var add = function (key, value) {
-        var node = {
+    const add = (key, value) => {
+        const node = {
             content: {
-                key: key,
+                key,
                 cachedAt: Date.now(),
-                value: value
+                value
             }
         };
         nodes[key] = node;
@@ -39,34 +37,25 @@ export var cache = function (max, ttl) {
         }
         first = key;
     };
-    var get = function (key, fetcher, ttl) { return __awaiter(void 0, void 0, void 0, function () {
-        var node, value, now;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    node = nodes[key];
-                    value = node === null || node === void 0 ? void 0 : node.content.value;
-                    now = Date.now();
-                    if (!(node === undefined ||
-                        (ttl && node.content.cachedAt < now - ttl) ||
-                        (cacheTtl && node.content.cachedAt < now - cacheTtl))) return [3 /*break*/, 2];
-                    return [4 /*yield*/, fetcher()];
-                case 1:
-                    value = _a.sent();
-                    _a.label = 2;
-                case 2:
-                    if (node) {
-                        remove(node.content.key);
-                    }
-                    add(key, value);
-                    if (size > max && last) {
-                        remove(last);
-                    }
-                    return [2 /*return*/, value];
-            }
-        });
-    }); };
+    const get = async (key, fetcher, ttl) => {
+        const node = nodes[key];
+        let value = node?.content.value;
+        const now = Date.now();
+        if (node === undefined ||
+            (ttl && node.content.cachedAt < now - ttl) ||
+            (cacheTtl && node.content.cachedAt < now - cacheTtl)) {
+            value = await fetcher();
+        }
+        if (node) {
+            remove(node.content.key);
+        }
+        add(key, value);
+        if (size > max && last) {
+            remove(last);
+        }
+        return value;
+    };
     return {
-        get: get
+        get
     };
 };

package/build/lib/constants.js

@@ -1 +1 @@
-export var UserProviderMiddlewareKey = "chat-backend-user-id";
+export const UserProviderMiddlewareKey = "chat-backend-user-id";

package/build/lib/getUserIdFromEvent.js

@@ -1,5 +1,5 @@
 import { UserProviderMiddlewareKey } from "./constants";
 // get User Id from Event
-export var getUserIdFromEvent = function (event) {
+export const getUserIdFromEvent = (event) => {
     return event.somodMiddlewareContext.get(UserProviderMiddlewareKey);
 };

package/build/lib/message.js

@@ -1,61 +1,46 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { marshall } from "@aws-sdk/util-dynamodb";
 import { typeToAllowedActionsMap } from "./types";
 import { DynamoDBClient, PutItemCommand } from "@aws-sdk/client-dynamodb";
 import { threadCache } from "./threadCache";
-var dynamodb = new DynamoDBClient();
-export var putMessage = function (tableName, userId, message) { return __awaiter(void 0, void 0, void 0, function () {
-    var msg, messageWithKeys, putItemCommand;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                msg = __assign(__assign({}, message), { seqNo: Date.now() });
-                messageWithKeys = __assign(__assign({}, msg), { userId: userId });
-                putItemCommand = new PutItemCommand({
-                    TableName: tableName,
-                    Item: marshall(messageWithKeys),
-                    ConditionExpression: "attribute_not_exists(#userId) AND attribute_not_exists(#seqNo)",
-                    ExpressionAttributeNames: {
-                        "#userId": "userId",
-                        "#seqNo": "seqNo"
-                    }
-                });
-                return [4 /*yield*/, dynamodb.send(putItemCommand)];
-            case 1:
-                _a.sent();
-                return [2 /*return*/, msg];
+const dynamodb = new DynamoDBClient();
+export const putMessage = async (tableName, userId, message) => {
+    const msg = {
+        ...message,
+        seqNo: Date.now()
+    };
+    const messageWithKeys = { ...msg, userId };
+    const putItemCommand = new PutItemCommand({
+        TableName: tableName,
+        Item: marshall(messageWithKeys),
+        ConditionExpression: "attribute_not_exists(#userId) AND attribute_not_exists(#seqNo)",
+        ExpressionAttributeNames: {
+            "#userId": "userId",
+            "#seqNo": "seqNo"
         }
     });
-}); };
-export var validateIncomingMessage = function (message, userId) { return __awaiter(void 0, void 0, void 0, function () {
-    var errorMessage, thread;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                errorMessage = undefined;
-                return [4 /*yield*/, threadCache.get(message.threadId)];
-            case 1:
-                thread = _a.sent();
-                if (thread === undefined) {
-                    errorMessage = "Invalid threadId : does not exist";
-                }
-                else if (!thread.participants.includes(userId)) {
-                    errorMessage = "Invalid threadId : from '".concat(userId, "' is not a participant in thread '").concat(thread.id, "'");
-                }
-                else if (!typeToAllowedActionsMap[message.type].includes(message.action)) {
-                    errorMessage = "Invalid action : action must be '".concat(typeToAllowedActionsMap[message.type].join(","), "' for '").concat(message.type, "' type");
-                }
-                if (errorMessage) {
-                    return [2 /*return*/, {
-                            statusCode: 400,
-                            headers: { "Content-Type": "application/json; charset=utf-8" },
-                            body: JSON.stringify({
-                                message: errorMessage,
-                                threadId: message.threadId
-                            })
-                        }];
-                }
-                return [2 /*return*/];
-        }
-    });
-}); };
+    await dynamodb.send(putItemCommand);
+    return msg;
+};
+export const validateIncomingMessage = async (message, userId) => {
+    let errorMessage = undefined;
+    const thread = await threadCache.get(message.threadId);
+    if (thread === undefined) {
+        errorMessage = "Invalid threadId : does not exist";
+    }
+    else if (!thread.participants.includes(userId)) {
+        errorMessage = `Invalid threadId : from '${userId}' is not a participant in thread '${thread.id}'`;
+    }
+    else if (!typeToAllowedActionsMap[message.type].includes(message.action)) {
+        errorMessage = `Invalid action : action must be '${typeToAllowedActionsMap[message.type].join(",")}' for '${message.type}' type`;
+    }
+    if (errorMessage) {
+        return {
+            statusCode: 400,
+            headers: { "Content-Type": "application/json; charset=utf-8" },
+            body: JSON.stringify({
+                message: errorMessage,
+                threadId: message.threadId
+            })
+        };
+    }
+};

package/build/lib/sessionUtil.js

@@ -1,79 +1,68 @@
-var _a, _b;
-import { __awaiter, __generator } from "tslib";
 import { verify } from "jsonwebtoken";
 import { sessionRequirement } from "./types";
 import { threadCache } from "./threadCache";
-var sessionJwtSecret = (_a = process.env.SESSION_SECRET) !== null && _a !== void 0 ? _a : "";
-var sessionForce = (_b = process.env.SESSION_FORCE) !== null && _b !== void 0 ? _b : "";
-export var Error = {
+const sessionJwtSecret = process.env.SESSION_SECRET ?? "";
+const sessionForce = process.env.SESSION_FORCE ?? "";
+export const Error = {
     required: "missing required field: sessionToken",
     invalid: "invalid field: sessionToken"
 };
-export var handleSessionToken = function (userId, threadId, type, action, sessionToken) { return __awaiter(void 0, void 0, void 0, function () {
-    var result, isSessionRequiredForThisTypeAction, oneDay_1, thread_1, sessionRequired, session, now;
-    var _a, _b, _c;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                result = { sessionId: "" };
-                if (!sessionJwtSecret) return [3 /*break*/, 6];
-                if (!!sessionToken) return [3 /*break*/, 5];
-                isSessionRequiredForThisTypeAction = (_a = sessionRequirement[type]) === null || _a === void 0 ? void 0 : _a[action];
-                if (!(isSessionRequiredForThisTypeAction !== undefined)) return [3 /*break*/, 4];
-                oneDay_1 = Date.now() + 1000 * 60 * 60 * 24;
-                if (!(isSessionRequiredForThisTypeAction === "always")) return [3 /*break*/, 1];
-                result.error = Error.required;
-                result.sessionRequiredTill = oneDay_1;
-                return [3 /*break*/, 4];
-            case 1:
-                if (!(isSessionRequiredForThisTypeAction === "thread")) return [3 /*break*/, 4];
-                if (!(sessionForce == "true")) return [3 /*break*/, 2];
-                result.error = Error.required;
-                result.sessionRequiredTill = oneDay_1;
-                return [3 /*break*/, 4];
-            case 2: return [4 /*yield*/, threadCache.get(threadId, -1)];
-            case 3:
-                thread_1 = _d.sent();
-                sessionRequired = Object.fromEntries((_c = (_b = thread_1 === null || thread_1 === void 0 ? void 0 : thread_1.sessionRequired) === null || _b === void 0 ? void 0 : _b.map(function (userId, index) {
-                    var _a, _b;
-                    return [
-                        userId,
-                        (_b = (_a = thread_1 === null || thread_1 === void 0 ? void 0 : thread_1.sessionRequiredTill) === null || _a === void 0 ? void 0 : _a[index]) !== null && _b !== void 0 ? _b : oneDay_1
-                    ];
-                })) !== null && _c !== void 0 ? _c : []);
-                if (sessionRequired[userId] !== undefined &&
-                    Date.now() < sessionRequired[userId]) {
+export const handleSessionToken = async (userId, threadId, type, action, sessionToken) => {
+    const result = { sessionId: "" };
+    if (sessionJwtSecret) {
+        if (!sessionToken) {
+            const isSessionRequiredForThisTypeAction = sessionRequirement[type]?.[action];
+            if (isSessionRequiredForThisTypeAction !== undefined) {
+                const oneDay = Date.now() + 1000 * 60 * 60 * 24; // 1 day
+                if (isSessionRequiredForThisTypeAction === "always") {
                     result.error = Error.required;
-                    result.sessionRequiredTill = sessionRequired[userId];
+                    result.sessionRequiredTill = oneDay;
                 }
-                _d.label = 4;
-            case 4: return [3 /*break*/, 6];
-            case 5:
-                try {
-                    session = verify(sessionToken, sessionJwtSecret + "", {
-                        algorithms: ["HS512"],
-                        ignoreExpiration: true
-                    });
-                    now = Date.now();
-                    if (session.participants.includes(userId) &&
-                        session.startTime <= now &&
-                        now <= session.endTime) {
-                        result.sessionId = session.id;
+                else if (isSessionRequiredForThisTypeAction === "thread") {
+                    if (sessionForce == "true") {
+                        result.error = Error.required;
+                        result.sessionRequiredTill = oneDay;
                     }
                     else {
-                        result.error = Error.invalid;
+                        const thread = await threadCache.get(threadId, -1); // ttl = -1 will force the cache to fetch from db
+                        const sessionRequired = Object.fromEntries(thread?.sessionRequired?.map((userId, index) => [
+                            userId,
+                            thread?.sessionRequiredTill?.[index] ?? oneDay
+                        ]) ?? []);
+                        if (sessionRequired[userId] !== undefined &&
+                            Date.now() < sessionRequired[userId]) {
+                            result.error = Error.required;
+                            result.sessionRequiredTill = sessionRequired[userId];
+                        }
                     }
                 }
-                catch (err) {
-                    // eslint-disable-next-line no-console
-                    console.error("session token verification failed. userId=" +
-                        userId +
-                        ", error=" +
-                        err);
+            }
+        }
+        else {
+            try {
+                const session = verify(sessionToken, sessionJwtSecret + "", {
+                    algorithms: ["HS512"],
+                    ignoreExpiration: true
+                });
+                const now = Date.now();
+                if (session.participants.includes(userId) &&
+                    session.startTime <= now &&
+                    now <= session.endTime) {
+                    result.sessionId = session.id;
+                }
+                else {
                     result.error = Error.invalid;
                 }
-                _d.label = 6;
-            case 6: return [2 /*return*/, result];
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error("session token verification failed. userId=" +
+                    userId +
+                    ", error=" +
+                    err);
+                result.error = Error.invalid;
+            }
         }
-    });
-}); };
+    }
+    return result;
+};

package/build/lib/threadCache.js

@@ -1,31 +1,18 @@
-import { __awaiter, __generator } from "tslib";
 import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
 import { cache } from "./cache";
 import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
-var dynamodb = new DynamoDBClient();
-var _threadCache = cache(100, 60 * 60000);
-export var threadCache = {
-    get: function (threadId, ttl) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, _threadCache.get(threadId, function () { return __awaiter(void 0, void 0, void 0, function () {
-                        var threadResult;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, dynamodb.send(new GetItemCommand({
-                                        TableName: process.env.THREAD_TABLE_NAME,
-                                        Key: marshall({ id: threadId })
-                                    }))];
-                                case 1:
-                                    threadResult = _a.sent();
-                                    return [2 /*return*/, threadResult.Item
-                                            ? unmarshall(threadResult.Item)
-                                            : undefined];
-                            }
-                        });
-                    }); }, ttl)];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    }); }
+const dynamodb = new DynamoDBClient();
+const _threadCache = cache(100, 60 * 60000);
+export const threadCache = {
+    get: async (threadId, ttl) => {
+        return await _threadCache.get(threadId, async () => {
+            const threadResult = await dynamodb.send(new GetItemCommand({
+                TableName: process.env.THREAD_TABLE_NAME,
+                Key: marshall({ id: threadId })
+            }));
+            return threadResult.Item
+                ? unmarshall(threadResult.Item)
+                : undefined;
+        }, ttl);
+    }
 };

package/build/lib/types.js

@@ -1,4 +1,4 @@
-export var typeToAllowedActionsMap = {
+export const typeToAllowedActionsMap = {
     text: ["new", "edit"],
     image: ["new", "edit"],
     control: [
@@ -15,7 +15,7 @@ export var typeToAllowedActionsMap = {
 /**
  * Store the message type and actions for which the session token is required
  */
-export var sessionRequirement = {
+export const sessionRequirement = {
     text: { new: "thread", edit: "thread" },
     image: { new: "thread", edit: "thread" },
     control: {

package/build/serverless/functions/message.js

@@ -1,4 +1,3 @@
-import { __assign, __awaiter, __generator, __rest } from "tslib";
 import { RouteBuilder } from "somod-http-extension";
 import { UserProviderMiddlewareKey } from "../../lib";
 import { putMessage, validateIncomingMessage } from "../../lib/message";
@@ -7,97 +6,85 @@ import { QueryCommand, DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { convertToAttr, unmarshall } from "@aws-sdk/util-dynamodb";
 import { handleSessionToken } from "../../lib/sessionUtil";
 import { getUserIdFromEvent } from "../../lib/getUserIdFromEvent";
-var dynamodb = new DynamoDBClient();
-var builder = new RouteBuilder();
-var postMessageHandler = function (request, event) { return __awaiter(void 0, void 0, void 0, function () {
-    var userId, messageValidationError, sessionIdResult, _a, sessionToken, msg, actions, message;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                userId = event.somodMiddlewareContext.get(UserProviderMiddlewareKey);
-                return [4 /*yield*/, validateIncomingMessage(request.body, userId)];
-            case 1:
-                messageValidationError = _b.sent();
-                if (messageValidationError) {
-                    return [2 /*return*/, messageValidationError];
-                }
-                return [4 /*yield*/, handleSessionToken(userId, request.body.threadId, request.body.type, request.body.action, request.body.sessionToken)];
-            case 2:
-                sessionIdResult = _b.sent();
-                if (sessionIdResult.error) {
-                    return [2 /*return*/, {
-                            statusCode: 400,
-                            headers: { "Content-Type": "application/json; charset=utf-8" },
-                            body: JSON.stringify({
-                                message: sessionIdResult.error,
-                                threadId: request.body.threadId,
-                                sessionRequiredTill: sessionIdResult.sessionRequiredTill
-                            })
-                        }];
-                }
-                _a = request.body, sessionToken = _a.sessionToken, msg = __rest(_a, ["sessionToken"]);
-                actions = ["sessionStart", "sessionExtend", "sessionEnd"];
-                return [4 /*yield*/, putMessage(process.env.MESSAGE_BOX_TABLE_NAME + "", userId, __assign(__assign(__assign({}, msg), { sessionId: sessionIdResult.sessionId, id: v1uuid().split("-").join(""), from: userId, sentAt: Date.now() }), (actions.includes(request.body.action)
-                        ? { sessionToken: sessionToken }
-                        : {})))];
-            case 3:
-                message = _b.sent();
-                return [2 /*return*/, {
-                        statusCode: 200,
-                        headers: { "Content-Type": "application/json; charset=utf-8" },
-                        body: JSON.stringify({
-                            id: message.id,
-                            seqNo: message.seqNo,
-                            sentAt: message.sentAt,
-                            from: message.from
-                        })
-                    }];
-        }
+const dynamodb = new DynamoDBClient();
+const builder = new RouteBuilder();
+const postMessageHandler = async (request, event) => {
+    const userId = event.somodMiddlewareContext.get(UserProviderMiddlewareKey);
+    const messageValidationError = await validateIncomingMessage(request.body, userId);
+    if (messageValidationError) {
+        return messageValidationError;
+    }
+    const sessionIdResult = await handleSessionToken(userId, request.body.threadId, request.body.type, request.body.action, request.body.sessionToken);
+    if (sessionIdResult.error) {
+        return {
+            statusCode: 400,
+            headers: { "Content-Type": "application/json; charset=utf-8" },
+            body: JSON.stringify({
+                message: sessionIdResult.error,
+                threadId: request.body.threadId,
+                sessionRequiredTill: sessionIdResult.sessionRequiredTill
+            })
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { sessionToken, ...msg } = request.body;
+    const actions = ["sessionStart", "sessionExtend", "sessionEnd"];
+    const message = await putMessage(process.env.MESSAGE_BOX_TABLE_NAME + "", userId, {
+        ...msg,
+        sessionId: sessionIdResult.sessionId,
+        id: v1uuid().split("-").join(""),
+        from: userId,
+        sentAt: Date.now(),
+        ...(actions.includes(request.body.action)
+            ? { sessionToken: sessionToken }
+            : {})
     });
-}); };
-var syncMessagesHandler = function (request, event) { return __awaiter(void 0, void 0, void 0, function () {
-    var userId, queryCommandInput, queryCommand, result, messages;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                userId = getUserIdFromEvent(event);
-                queryCommandInput = {
-                    TableName: process.env.MESSAGE_BOX_TABLE_NAME + "",
-                    KeyConditionExpression: "#userId = :userId",
-                    ExpressionAttributeNames: {
-                        "#userId": "userId"
-                    },
-                    ExpressionAttributeValues: {
-                        ":userId": convertToAttr(userId)
-                    },
-                    Limit: 100
-                };
-                if (request.parameters.query.from) {
-                    queryCommandInput.KeyConditionExpression += " AND #seqNo >= :seqNo";
-                    queryCommandInput.ExpressionAttributeNames["#seqNo"] = "seqNo";
-                    queryCommandInput.ExpressionAttributeValues[":seqNo"] = {
-                        N: request.parameters.query.from
-                    };
-                }
-                queryCommand = new QueryCommand(queryCommandInput);
-                return [4 /*yield*/, dynamodb.send(queryCommand)];
-            case 1:
-                result = _a.sent();
-                messages = (result.Items || []).map(function (item) {
-                    var message = unmarshall(item);
-                    delete message.userId;
-                    return message;
-                });
-                return [2 /*return*/, {
-                        statusCode: 200,
-                        headers: {
-                            "Content-Type": "application/json; charset=utf-8"
-                        },
-                        body: JSON.stringify(messages)
-                    }];
-        }
+    return {
+        statusCode: 200,
+        headers: { "Content-Type": "application/json; charset=utf-8" },
+        body: JSON.stringify({
+            id: message.id,
+            seqNo: message.seqNo,
+            sentAt: message.sentAt,
+            from: message.from
+        })
+    };
+};
+const syncMessagesHandler = async (request, event) => {
+    const userId = getUserIdFromEvent(event);
+    const queryCommandInput = {
+        TableName: process.env.MESSAGE_BOX_TABLE_NAME + "",
+        KeyConditionExpression: "#userId = :userId",
+        ExpressionAttributeNames: {
+            "#userId": "userId"
+        },
+        ExpressionAttributeValues: {
+            ":userId": convertToAttr(userId)
+        },
+        Limit: 100
+    };
+    if (request.parameters.query.from) {
+        queryCommandInput.KeyConditionExpression += " AND #seqNo >= :seqNo";
+        queryCommandInput.ExpressionAttributeNames["#seqNo"] = "seqNo";
+        queryCommandInput.ExpressionAttributeValues[":seqNo"] = {
+            N: request.parameters.query.from
+        };
+    }
+    const queryCommand = new QueryCommand(queryCommandInput);
+    const result = await dynamodb.send(queryCommand);
+    const messages = (result.Items || []).map(item => {
+        const message = unmarshall(item);
+        delete message.userId;
+        return message;
     });
-}); };
+    return {
+        statusCode: 200,
+        headers: {
+            "Content-Type": "application/json; charset=utf-8"
+        },
+        body: JSON.stringify(messages)
+    };
+};
 builder.add("/post-message", "POST", postMessageHandler);
 builder.add("/sync-messages", "GET", syncMessagesHandler);
 export default builder.getHandler();