wa-chat-server/lib/api/conversation.js

Watson Assistant powered chat server

"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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.conversationAPI = conversationAPI;
const express_1 = __importDefault(require("express"));
const MessageResponseFilter_1 = require("../class/MessageResponseFilter");
const MessageRequestFilter_1 = require("../class/MessageRequestFilter");
const Session_1 = require("../class/Session/Session");
const processMessage_1 = require("../methods/processMessage");
function conversationAPI(logger, config, servicesRegistrator) {
    const preProcessingServices = servicesRegistrator.getPreProcessingServices();
    const postProcessingServices = servicesRegistrator.getPostProcessingServices();
    const conversationServices = servicesRegistrator.getConversationServices();
    return (watsonAssistants) => {
        const router = express_1.default.Router();
        router.use(express_1.default.json({ limit: '1mb' }));
        router.get('/(|v1/)workspaces', (req, res) => {
            res.json({
                workspaces: [
                    {
                        workspaceId: 'default',
                        name: 'default',
                    },
                ],
            });
        });
        router.post('/(|v1/)workspaces/getHistory', (req, res) => __awaiter(this, void 0, void 0, function* () {
            const logHeader = `POST ${req.path}`;
            const startTimeMS = new Date().getTime();
            if (String(config.history_enabled) === 'false') {
                res.json(false);
                return;
            }
            try {
                const session = yield new Session_1.Session(req.body.sessionId).start();
                if (session.data.history.length > 0)
                    res.json(session.data.history);
                else
                    res.json([]);
            }
            catch (e) {
                logger.error(`${logHeader}, sessionId=${req.body.sessionId}`, {
                    request: req.body,
                    durationMS: `${new Date().getTime() - startTimeMS}`,
                });
                res.statusCode = 400;
            }
        }));
        router.post('/(|v1/)workspaces/default/message', (req, res) => __awaiter(this, void 0, void 0, function* () {
            const resetWord = 'reset';
            const logHeader = `POST ${req.path}`;
            const startTimeMS = new Date().getTime();
            const session = yield new Session_1.Session(req.body.sessionId).start();
            const requestFilter = new MessageRequestFilter_1.MessageRequestFilter(logger, config, session);
            const responseFilter = new MessageResponseFilter_1.MessageResponseFilter(session);
            const payload = yield requestFilter.applyTo(req);
            if (!payload.input) {
                res.status(400);
                const text = 'missing input';
                logger.warn(logHeader, { request: req.body, response: { status: 400, text } });
                res.send(text);
            }
            const meta = payload.meta || {};
            try {
                const { newPayload, addons } = yield (0, processMessage_1.processMessage)({
                    session,
                    watsonAssistants,
                    preProcessingServices,
                    postProcessingServices,
                    conversationServices,
                    payload,
                    meta,
                    config,
                    logger,
                });
                const response = Object.assign({}, responseFilter.applyTo(newPayload, addons));
                logger.info(`${logHeader}, sessionId=${response.sessionId}`, {
                    request: req.body,
                    response,
                    durationMS: `${new Date().getTime() - startTimeMS}`,
                });
                if (String(config.history_enabled) === 'true') {
                    try {
                        if (req.body.sessionId && response.result.input.text.toLowerCase() != resetWord) {
                            session.data.history.push(response.result);
                        }
                        else if (response.result.input.text.toLowerCase() === resetWord) {
                            session.data.history = [];
                        }
                    }
                    catch (e) {
                        logger.error(e);
                    }
                }
                res.json(response);
            }
            catch (e) {
                const error = responseFilter.error(payload.input, e.message);
                logger.error(`${logHeader}, sessionId=${req.body.sessionId}`, {
                    request: req.body,
                    error,
                    durationMS: `${new Date().getTime() - startTimeMS}`,
                });
                res.json(error);
            }
        }));
        return router;
    };
}