@hexabot-ai/api 3.1.4-alpha.0 → 3.2.1-alpha.0

package/dist/extensions/channels/web/base-web-channel.js

@@ -8,76 +8,99 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@hexabot-ai/types");
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
 const socket_io_1 = require("socket.io");
 const uuid_1 = require("uuid");
 const attachment_entity_1 = require("../../../attachment/entities/attachment.entity");
-const types_1 = require("../../../attachment/types");
-const Handler_1 = __importDefault(require("../../../channel/lib/Handler"));
-const outbound_1 = require("../../../channel/lib/outbound");
-const channel_attachment_service_1 = require("../../../channel/services/channel-attachment.service");
+const types_2 = require("../../../attachment/types");
+const channel_1 = require("../../../channel");
+const source_service_1 = require("../../../channel/services/source.service");
 const message_service_1 = require("../../../chat/services/message.service");
-const subscriber_service_1 = require("../../../chat/services/subscriber.service");
-const thread_service_1 = require("../../../chat/services/thread.service");
-const button_1 = require("../../../chat/types/button");
-const message_1 = require("../../../chat/types/message");
 const menu_service_1 = require("../../../cms/services/menu.service");
 const config_1 = require("../../../config");
-const websocket_gateway_1 = require("../../../websocket/websocket.gateway");
 const inbound_1 = require("./inbound");
-const outbound_2 = require("./outbound");
-const types_2 = require("./types");
-let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.default {
-    constructor(name) {
-        super(name);
+const outbound_1 = require("./outbound");
+const web_history_service_1 = require("./services/web-history.service");
+const web_session_service_1 = require("./services/web-session.service");
+const types_3 = require("./types");
+let BaseWebChannelHandler = class BaseWebChannelHandler extends channel_1.WebSocketChannelHandler {
+    constructor(name, sourceSettingsSchema) {
+        super(name, sourceSettingsSchema);
     }
     async onModuleInit() {
         await super.onModuleInit();
-        const OutboundMessageEncoderProvider = (0, outbound_2.createWebOutboundMessageEncoder)(this.getName());
-        const InboundEventDecoderProvider = (0, inbound_1.createWebInboundEventDecoder)(this.getName());
-        [this.outboundMessageEncoder, this.inboundEventDecoder] = await Promise.all([
-            this.createModuleRef(OutboundMessageEncoderProvider),
-            this.createModuleRef(InboundEventDecoderProvider),
-        ]);
         this.logger.debug('initialization ...');
     }
+    getCapabilities() {
+        return { ...channel_1.DEFAULT_CHANNEL_CAPABILITIES, typingIndicator: true };
+    }
+    generateId() {
+        return `${this.name}-${(0, uuid_1.v4)()}`;
+    }
+    getChannelAttributes(req) {
+        return {
+            isSocket: true,
+            ipAddress: this.getIpAddress(req),
+            agent: req.headers['user-agent'] || 'browser',
+        };
+    }
+    formatCtx(sourceId) {
+        return {
+            inboundEncoder: this.inboundMessageEncoder,
+            outboundEncoder: this.outboundMessageEncoder,
+            generateId: () => this.generateId(),
+            sourceId,
+        };
+    }
+    getSourceIdFromHandshake(client) {
+        const rawSourceId = client.handshake.query.source_id;
+        const sourceId = Array.isArray(rawSourceId) ? rawSourceId[0] : rawSourceId;
+        if (typeof sourceId !== 'string') {
+            return null;
+        }
+        const normalizedSourceId = sourceId.trim();
+        return normalizedSourceId.length > 0 ? normalizedSourceId : null;
+    }
     async onWebSocketConnection(client) {
         try {
-            const handshake = client.handshake;
-            const { channel } = handshake.query;
+            const sourceId = this.getSourceIdFromHandshake(client);
+            if (!sourceId) {
+                if (client.request.session.passport?.user?.id) {
+                    return;
+                }
+                this.logger.warn('Missing source_id in websocket handshake');
+                client.disconnect();
+                return;
+            }
+            const source = await this.sourceService.findActiveById(sourceId);
             const profile = client.request.session.web?.profile;
-            if (channel !== this.getName()) {
+            if (source.channel !== this.getName()) {
                 return;
             }
+            client.request.session.web = {
+                ...client.request.session.web,
+                sourceId,
+            };
             let messages;
             let threadId;
             if (profile?.foreignId) {
                 await client.join(profile.foreignId);
-                const thread = await this.threadService.resolveThread({
-                    subscriberId: profile.id,
-                    explicitThreadId: client.request.session.web?.threadId,
-                });
+                const thread = await this.sessionService.resolveThread(profile.id, client.request.session.web?.threadId);
                 threadId = thread?.id;
-                const currentWebSession = client.request.session.web;
                 client.request.session.web = {
-                    profile: currentWebSession?.profile,
+                    profile: client.request.session.web?.profile,
                     threadId,
+                    sourceId,
                 };
-                if (thread) {
-                    const messagesHistory = await this.messageService.findHistoryUntilDate(thread);
-                    messages = await this.formatMessages(messagesHistory.reverse());
-                }
-                else {
-                    messages = [];
-                }
+                messages = thread
+                    ? await this.historyService.fetchHistory(thread, this.formatCtx(source.id))
+                    : [];
             }
             this.logger.debug('WS connected .. sending settings');
-            const settings = await this.getSettings();
+            const settings = source.settings;
             try {
                 const menu = await this.menuService.getTree();
                 client.emit('settings', {
@@ -111,253 +134,63 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                 message: 'Internal Server Error',
             });
         const subscriber = socket.request.session.web?.profile;
-        if (socket.handshake.query.channel !== this.getName() || !subscriber) {
+        const sourceId = this.getSourceIdFromHandshake(socket);
+        if (!sourceId ||
+            socket.request.session.web?.sourceId !== sourceId ||
+            !subscriber) {
             return;
         }
-        this.broadcast(subscriber, message_1.StdEventType.error, response, [socket.id]);
+        this.broadcast(subscriber, types_1.StdEventType.error, response, [socket.id]);
     }
-    async formatIncomingHistoryMessage(incoming) {
-        if ('type' in incoming.message) {
-            if (incoming.message.type === button_1.PayloadType.location) {
-                const coordinates = incoming.message.coordinates;
-                return {
-                    type: types_2.Web.InboundMessageType.location,
-                    data: {
-                        coordinates: {
-                            lat: coordinates.lat,
-                            lng: coordinates.lon,
-                        },
-                    },
-                };
-            }
-            else {
-                const attachmentPayload = Array.isArray(incoming.message.attachment)
-                    ? incoming.message.attachment[0]
-                    : incoming.message.attachment;
-                return {
-                    type: types_2.Web.InboundMessageType.file,
-                    data: {
-                        type: attachmentPayload.type,
-                        url: await this.channelAttachmentService.getPublicUrl(this.getName(), attachmentPayload.payload),
-                    },
-                };
-            }
-        }
-        else {
+    async ensureValidCors(req, res, source) {
+        const allowedDomains = typeof source.settings.allowed_domains === 'string'
+            ? source.settings.allowed_domains
+            : '*';
+        await this.sessionService.validateCors(req, res, allowedDomains);
+    }
+    async getOrCreateSession(req, source) {
+        return this.sessionService.getOrCreateSession(req, source.id, () => {
+            const data = req.query;
             return {
-                type: types_2.Web.InboundMessageType.text,
-                data: incoming.message,
+                foreignId: this.generateId(),
+                firstName: data.first_name ? String(data.first_name) : 'Anon.',
+                lastName: data.last_name ? String(data.last_name) : 'Web User',
+                assignedTo: null,
+                assignedAt: null,
+                lastvisit: new Date(),
+                retainedFrom: new Date(),
+                avatar: null,
+                channel: {
+                    name: this.getName(),
+                    data: this.getChannelAttributes(req),
+                },
+                language: '',
+                locale: '',
+                timezone: 0,
+                gender: 'male',
+                country: '',
+                labels: [],
+                source: source.id,
             };
-        }
-    }
-    async formatOutgoingHistoryMessage(outgoing) {
-        const envelope = (0, outbound_1.inferOutgoingMessageEnvelope)(outgoing.message);
-        const options = 'options' in outgoing.message
-            ? {
-                content: outgoing.message.options,
-            }
-            : {};
-        return await this.outboundMessageEncoder.encode(envelope, options);
-    }
-    isIncomingMessage(message) {
-        return 'sender' in message && !!message.sender;
-    }
-    async formatMessages(messages) {
-        const formattedMessages = [];
-        for (const anyMessage of messages) {
-            const messageMid = anyMessage.mid ?? this.generateId();
-            if (this.isIncomingMessage(anyMessage)) {
-                const message = await this.formatIncomingHistoryMessage(anyMessage);
-                formattedMessages.push({
-                    ...message,
-                    author: anyMessage.sender,
-                    read: true,
-                    mid: messageMid,
-                    createdAt: anyMessage.createdAt,
-                });
-            }
-            else {
-                const message = await this.formatOutgoingHistoryMessage(anyMessage);
-                formattedMessages.push({
-                    ...message,
-                    author: 'chatbot',
-                    read: true,
-                    mid: messageMid,
-                    handover: !!anyMessage.handover,
-                    createdAt: anyMessage.createdAt,
-                });
-            }
-        }
-        return formattedMessages;
-    }
-    normalizeThreadId(raw) {
-        if (typeof raw !== 'string') {
-            return undefined;
-        }
-        const value = raw.trim();
-        return value.length > 0 ? value : undefined;
-    }
-    getThreadIdFromQuery(req) {
-        const raw = req.query.thread_id;
-        const candidate = Array.isArray(raw) ? raw[0] : raw;
-        return this.normalizeThreadId(candidate);
-    }
-    getThreadIdFromBody(req) {
-        const body = req.body;
-        return this.normalizeThreadId(body?.thread_id);
-    }
-    async resolveThreadForHistory(req) {
-        const profile = req.session.web?.profile;
-        if (!profile?.id) {
-            return null;
-        }
-        const explicitThreadId = this.getThreadIdFromQuery(req) ?? this.getThreadIdFromBody(req);
-        const thread = await this.threadService.resolveThread({
-            subscriberId: profile.id,
-            explicitThreadId,
         });
-        if (req.session.web) {
-            req.session.web.threadId = thread?.id;
-        }
-        return thread;
-    }
-    async fetchHistory(req, until = new Date(), n = 30) {
-        const thread = await this.resolveThreadForHistory(req);
-        if (thread) {
-            const messages = await this.messageService.findHistoryUntilDate(thread, until, n);
-            return await this.formatMessages(messages.reverse());
-        }
-        return [];
-    }
-    async ensureValidCors(req, res) {
-        if (!req.headers?.origin) {
-            this.logger.debug('No origin ', req.headers);
-            throw new Error('CORS - No origin provided!');
-        }
-        const originUrl = new URL(req.headers.origin);
-        const allowedProtocols = new Set(['http:', 'https:']);
-        if (!allowedProtocols.has(originUrl.protocol)) {
-            throw new Error('CORS - Invalid origin!');
-        }
-        const settings = await this.getSettings();
-        const origins = settings.allowed_domains.split(',');
-        const foundOrigin = origins
-            .filter((origin) => origin.trim() !== '*')
-            .map((origin) => {
-            try {
-                return new URL(origin.trim()).origin;
-            }
-            catch (error) {
-                this.logger.error(`Invalid URL in allowed domains: ${origin}`, error);
-                return null;
-            }
-        })
-            .filter((normalizedOrigin) => normalizedOrigin !== null)
-            .some((origin) => {
-            return origin === originUrl.origin;
-        });
-        if (!foundOrigin && !origins.includes('*')) {
-            res.set('Access-Control-Allow-Origin', '');
-            this.logger.debug('No origin found ', req.headers.origin);
-            throw new Error('CORS - Domain not allowed!');
-        }
-        else {
-            res.set('Access-Control-Allow-Origin', originUrl.origin);
-        }
-        res.set('Access-Control-Allow-Credentials', 'true');
-        res.set('Access-Control-Expose-Headers', '');
-        if (req.method == 'OPTIONS') {
-            res.set('Access-Control-Allow-Methods', 'GET, POST');
-            res.set('Access-Control-Allow-Headers', 'content-type');
-        }
     }
-    async validateSession(req, res) {
-        if (req.session.web?.profile?.id) {
-            return req.session.web.profile;
-        }
-        const body = req.body;
-        const authorForeignId = typeof body?.author === 'string' && body.author.trim().length > 0
-            ? body.author.trim()
-            : undefined;
-        if (authorForeignId) {
-            try {
-                const subscriber = await this.subscriberService.findOneByForeignId(authorForeignId);
-                if (subscriber) {
-                    const thread = await this.threadService.resolveThread({
-                        subscriberId: subscriber.id,
-                        explicitThreadId: this.getThreadIdFromBody(req) ?? this.getThreadIdFromQuery(req),
-                    });
-                    req.session.web = {
-                        profile: subscriber,
-                        threadId: thread?.id,
-                    };
-                    this.logger.debug(`Recovered missing web session from author ${authorForeignId}`);
-                    return subscriber;
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Unable to recover missing session from author ${authorForeignId}`, error);
-            }
-        }
-        this.logger.warn('No session ID to be found!', req.session);
-        res.status(403).json({ err: 'Web Channel Handler : Unauthorized!' });
-        return null;
-    }
-    async getOrCreateSession(req) {
-        const data = req.query;
-        const sessionProfile = req.session.web?.profile;
-        if (sessionProfile) {
-            const subscriber = await this.subscriberService.findOne(sessionProfile.id);
-            if (!subscriber || !req.session.web) {
-                throw new Error('Subscriber session was not persisted in DB');
-            }
-            const thread = await this.threadService.resolveThread({
-                subscriberId: subscriber.id,
-                explicitThreadId: req.session.web.threadId,
-            });
-            req.session.web.profile = subscriber;
-            req.session.web.threadId = thread?.id;
-            return subscriber;
-        }
-        const newProfile = {
-            foreignId: this.generateId(),
-            firstName: data.first_name ? data.first_name.toString() : 'Anon.',
-            lastName: data.last_name ? data.last_name.toString() : 'Web User',
-            assignedTo: null,
-            assignedAt: null,
-            lastvisit: new Date(),
-            retainedFrom: new Date(),
-            avatar: null,
-            channel: {
-                name: this.getName(),
-                data: this.getChannelAttributes(req),
-            },
-            language: '',
-            locale: '',
-            timezone: 0,
-            gender: 'male',
-            country: '',
-            labels: [],
-        };
-        const profile = await this.subscriberService.create(newProfile);
-        req.session.web = {
-            profile,
-        };
-        return profile;
-    }
-    async subscribe(req, res) {
+    async subscribe(req, res, source) {
         this.logger.debug('subscribe (isSocket=true)');
         try {
-            const profile = await this.getOrCreateSession(req);
+            const profile = await this.getOrCreateSession(req, source);
+            const profileForeignId = profile.foreignId;
+            if (!profileForeignId) {
+                throw new Error('Session profile foreignId is missing');
+            }
             try {
-                await req.socket.join(profile.foreignId);
+                await req.socket.join(profileForeignId);
             }
             catch (err) {
                 this.logger.error('Unable to subscribe via websocket', err);
             }
-            const criteria = 'since' in req.query ? req.query.since : req.body?.since || undefined;
-            const messages = await this.fetchHistory(req, criteria);
-            return res.status(200).json({
+            const criteria = 'since' in req.query ? req.query.since : (req.body?.since ?? undefined);
+            const messages = await this.historyService.fetchHistoryForRequest(req, this.sessionService, this.formatCtx(source.id), criteria);
+            res.status(200).json({
                 profile,
                 messages,
                 thread_id: req.session.web?.threadId ?? null,
@@ -365,7 +198,7 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         }
         catch (err) {
             this.logger.warn('Unable to subscribe ', err);
-            return res.status(500).json({ err: 'Unable to subscribe' });
+            res.status(500).json({ err: 'Unable to subscribe' });
         }
     }
     async handleWsUpload(req) {
@@ -375,24 +208,25 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                 this.logger.debug('No session provided');
                 return null;
             }
-            if (type !== types_2.Web.InboundMessageType.file) {
+            if (type !== types_3.Web.InboundMessageType.file) {
                 this.logger.debug('No files provided');
                 return null;
             }
             if (!('file' in data) || !data.file) {
                 throw new Error('File payload is missing');
             }
+            const { name: fileName, type: mimeType } = data;
             const size = Buffer.byteLength(data.file);
             if (size > config_1.config.parameters.maxUploadSize) {
                 throw new Error('Max upload size has been exceeded');
             }
             return await this.attachmentService.store(data.file, {
-                name: data.name,
+                name: fileName,
                 size,
-                type: data.type,
-                resourceRef: types_1.AttachmentResourceRef.MessageAttachment,
-                access: types_1.AttachmentAccess.Private,
-                createdByRef: types_1.AttachmentCreatedByRef.Subscriber,
+                type: mimeType,
+                resourceRef: types_2.AttachmentResourceRef.MessageAttachment,
+                access: types_2.AttachmentAccess.Private,
+                createdByRef: types_2.AttachmentCreatedByRef.Subscriber,
                 createdBy: req.session.web.profile.id,
             });
         }
@@ -401,23 +235,13 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             throw new Error('Unable to upload file!');
         }
     }
-    getIpAddress(req) {
-        return req.socket.handshake.address;
-    }
-    getChannelAttributes(req) {
-        return {
-            isSocket: true,
-            ipAddress: this.getIpAddress(req),
-            agent: req.headers['user-agent'] || 'browser',
-        };
-    }
-    async handleEvent(req, res, workflowId) {
+    async handleEvent(req, res, source, workflowId) {
         if (!req.body) {
             this.logger.debug('Empty body');
             res.status(400).json({ err: 'Web Channel Handler : Bad Request!' });
             return;
         }
-        else if (typeof req.body === 'object' &&
+        if (typeof req.body === 'object' &&
             req.body !== null &&
             'data' in req.body) {
             const payload = req.body;
@@ -426,10 +250,9 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                     ? JSON.parse(payload.data)
                     : payload.data;
         }
-        const profile = await this.validateSession(req, res);
-        if (!profile) {
+        const profile = await this.sessionService.validateSession(req, res, source.id);
+        if (!profile)
             return;
-        }
         const channelAttrs = this.getChannelAttributes(req);
         let events;
         try {
@@ -446,25 +269,25 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                 .status(400)
                 .json({ err: 'Web Channel Handler : Bad Request!' });
         }
-        const explicitThreadId = this.getThreadIdFromBody(req) ??
-            this.getThreadIdFromQuery(req) ??
+        const explicitThreadId = this.sessionService.getThreadIdFromBody(req) ??
+            this.sessionService.getThreadIdFromQuery(req) ??
             req.session.web?.threadId;
         const responseBody = events[0].getRaw();
         for (const event of events) {
             event.setHandler(this);
-            if (explicitThreadId) {
+            event.setSourceContext(source.id, source.settings);
+            if (explicitThreadId)
                 event.setThreadId(explicitThreadId);
-            }
             event.setInitiator(profile);
             event.setWorkflowId(workflowId);
-            if (event.getEventType() === message_1.StdEventType.message) {
+            if (event.getEventType() === types_1.StdEventType.message) {
                 const messageEvent = event;
                 if (messageEvent instanceof inbound_1.AttachmentMessageInboundEvent) {
                     try {
                         const attachment = await this.handleWsUpload(req);
                         if (attachment) {
                             messageEvent.setUploadedAttachment(attachment);
-                            messageEvent.setUploadedRawData(attachment_entity_1.AttachmentOrmEntity.getTypeByMime(attachment.type), await this.channelAttachmentService.getPublicUrl(this.getName(), attachment));
+                            messageEvent.setUploadedRawData(attachment_entity_1.AttachmentOrmEntity.getTypeByMime(attachment.type), await this.channelAttachmentService.getPublicUrl(source.id, attachment));
                         }
                     }
                     catch (err) {
@@ -475,97 +298,86 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                     }
                 }
                 if (messageEvent.isSyncFromChatbot()) {
-                    const thread = await this.threadService.resolveThread({
-                        subscriberId: profile.id,
-                        explicitThreadId,
-                    });
+                    const thread = await this.sessionService.resolveThreadForHistory(req, profile.id);
                     if (!thread) {
                         return void res.status(409).json({
                             err: 'Web Channel Handler : No thread available before first user message',
                         });
                     }
                     messageEvent.setThreadId(thread.id);
-                    if (req.session.web) {
+                    if (req.session.web)
                         req.session.web.threadId = thread.id;
-                    }
                     const sentMessage = {
                         mid: messageEvent.getId(),
-                        message: messageEvent.getMessage(),
+                        message: {
+                            type: types_1.OutgoingMessageType.text,
+                            data: { text: messageEvent.getText() },
+                        },
                         recipient: profile.id,
                         thread: thread.id,
                         read: true,
                         delivery: true,
                     };
-                    this.eventEmitter.emit('hook:chatbot:sent', sentMessage, messageEvent);
+                    this.channelEventBus.emitSent(sentMessage, messageEvent);
                     continue;
                 }
                 messageEvent.setMessageId(this.generateId());
-                messageEvent.setAuthorForeignId(profile.foreignId);
+                if (profile.foreignId) {
+                    messageEvent.setAuthorForeignId(profile.foreignId);
+                }
                 messageEvent.setCreatedAt(new Date());
-                this.broadcast(profile, message_1.StdEventType.message, messageEvent.getRaw());
-                await this.eventEmitter.emitAsync('hook:chatbot:message', messageEvent);
+                this.broadcast(profile, types_1.StdEventType.message, messageEvent.getRaw());
+                await this.channelEventBus.emitMessage(messageEvent);
                 const resolvedThreadId = messageEvent.getThreadId();
                 if (resolvedThreadId) {
                     messageEvent.setThreadIdOnRaw(resolvedThreadId);
-                    if (req.session.web) {
+                    if (req.session.web)
                         req.session.web.threadId = resolvedThreadId;
-                    }
                 }
                 continue;
             }
             const type = event.getEventType();
             const threadId = event.getThreadId();
-            if (threadId) {
+            if (threadId)
                 event.setThreadIdOnRaw(threadId);
-            }
             this.broadcast(profile, type, event.getRaw());
-            this.eventEmitter.emit(`hook:chatbot:${type}`, event);
+            this.channelEventBus.emitStatusEvent(event);
         }
         res.status(200).json(responseBody);
     }
-    isSocketRequest(req) {
-        return 'isSocket' in req && req.isSocket;
-    }
-    async handle(req, res, workflowId) {
-        if (!this.isSocketRequest(req)) {
-            this.logger.warn('Web channel over HTTP is no longer supported. Use Socket.IO transport.');
-            return res
-                .status(403)
-                .json({ err: 'Web Channel Handler : Unauthorized!' });
-        }
+    async processSocketGet(req, res, source) {
         try {
-            await this.ensureValidCors(req, res);
-            if (req.method === 'GET') {
-                if (req.query._disconnect) {
-                    req.session.web = undefined;
-                    return res.status(200).json({ _disconnect: true });
-                }
-                else {
-                    return await this.subscribe(req, res);
-                }
-            }
-            else {
-                return this.handleEvent(req, res, workflowId);
+            await this.ensureValidCors(req, res, source);
+            if (req.query._disconnect) {
+                req.session.web = undefined;
+                return void res.status(200).json({ _disconnect: true });
             }
+            await this.subscribe(req, res, source);
         }
         catch (err) {
             this.logger.warn('Request check failed', err);
-            return res
-                .status(403)
-                .json({ err: 'Web Channel Handler : Unauthorized!' });
+            res.status(403).json({ err: 'Web Channel Handler : Unauthorized!' });
         }
     }
-    generateId() {
-        return `${this.name}-${(0, uuid_1.v4)()}`;
-    }
-    broadcast(subscriber, type, content, excludedRooms = []) {
-        this.websocketGateway.broadcast(subscriber, type, content, excludedRooms);
-    }
-    async sendMessage(event, envelope, options) {
-        if (envelope.format === message_1.OutgoingMessageFormat.system) {
-            throw new outbound_1.UnsupportedOutgoingFormatError(envelope.format);
+    async processSocketPost(req, res, source, workflowId) {
+        try {
+            await this.ensureValidCors(req, res, source);
+            await this.handleEvent(req, res, source, workflowId);
         }
-        const messageBase = await this.outboundMessageEncoder.encode(envelope, options ?? {});
+        catch (err) {
+            this.logger.warn('Request check failed', err);
+            res.status(403).json({ err: 'Web Channel Handler : Unauthorized!' });
+        }
+    }
+    async doSendMessage(event, envelope, options) {
+        const sourceId = event.getSourceId();
+        if (!sourceId) {
+            throw new Error(`Missing sourceId while sending ${this.getName()} outbound message`);
+        }
+        const messageBase = await this.outboundMessageEncoder.encode(envelope, {
+            ...(options ?? {}),
+            sourceId,
+        });
         const subscriber = event.getInitiator();
         const message = {
             ...messageBase,
@@ -575,90 +387,84 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             createdAt: new Date(),
             handover: !!(options && options.assignTo),
         };
-        const next = async () => {
-            this.broadcast(subscriber, message_1.StdEventType.message, message);
+        const send = async () => {
+            this.broadcast(subscriber, types_1.StdEventType.message, message);
             return { mid: message.mid };
         };
-        if (options && options.typing) {
-            const autoTimeout = message && message.data && 'text' in message.data
+        if (options?.typing) {
+            const autoTimeout = message?.data && 'text' in message.data
                 ? message.data.text.length * 10
                 : 1000;
             const timeout = typeof options.typing === 'number' ? options.typing : autoTimeout;
             try {
                 await this.sendTypingIndicator(subscriber, timeout);
-                return next();
+                return send();
             }
             catch (err) {
                 this.logger.error('Failed in sending typing indicator ', err);
             }
         }
-        return next();
-    }
-    async sendTypingIndicator(recipient, timeout) {
-        return new Promise((resolve, reject) => {
-            try {
-                this.broadcast(recipient, message_1.StdEventType.typing, true);
-                setTimeout(() => {
-                    this.broadcast(recipient, message_1.StdEventType.typing, false);
-                    return resolve();
-                }, timeout);
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
+        return send();
     }
     async getSubscriberData(event) {
         const sender = event.getInitiator();
-        const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...rest } = sender;
-        const subscriber = {
+        if (!sender.source) {
+            throw new Error('Unable to resolve subscriber source for web channel');
+        }
+        const { id: _id, createdAt: _c, updatedAt: _u, ...rest } = sender;
+        return {
             ...rest,
+            source: sender.source,
             channel: sender.channel,
         };
-        return subscriber;
     }
     async hasDownloadAccess(attachment, req) {
         const subscriberId = req.session.web?.profile?.id;
-        if (attachment.access === types_1.AttachmentAccess.Public) {
+        if (attachment.access === types_2.AttachmentAccess.Public)
             return true;
-        }
-        else if (!subscriberId) {
+        if (!subscriberId) {
             this.logger.warn(`Unauthorized access attempt to attachment ${attachment.id}`);
             return false;
         }
-        else if (attachment.createdByRef === types_1.AttachmentCreatedByRef.Subscriber &&
+        if (attachment.createdByRef === types_2.AttachmentCreatedByRef.Subscriber &&
             subscriberId === attachment.createdBy) {
             return true;
         }
-        else {
-            return await this.messageService.isAttachmentAccessibleBySubscriber(subscriberId, attachment.id);
-        }
+        return this.messageService.isAttachmentAccessibleBySubscriber(subscriberId, attachment.id);
     }
 };
 __decorate([
-    (0, common_1.Inject)(subscriber_service_1.SubscriberService),
-    __metadata("design:type", subscriber_service_1.SubscriberService)
-], BaseWebChannelHandler.prototype, "subscriberService", void 0);
+    (0, common_1.Inject)(menu_service_1.MenuService),
+    __metadata("design:type", menu_service_1.MenuService)
+], BaseWebChannelHandler.prototype, "menuService", void 0);
 __decorate([
     (0, common_1.Inject)(message_service_1.MessageService),
     __metadata("design:type", message_service_1.MessageService)
 ], BaseWebChannelHandler.prototype, "messageService", void 0);
 __decorate([
-    (0, common_1.Inject)(menu_service_1.MenuService),
-    __metadata("design:type", menu_service_1.MenuService)
-], BaseWebChannelHandler.prototype, "menuService", void 0);
+    (0, common_1.Inject)(source_service_1.SourceService),
+    __metadata("design:type", source_service_1.SourceService)
+], BaseWebChannelHandler.prototype, "sourceService", void 0);
+__decorate([
+    (0, channel_1.ExtensionInject)((name) => (0, outbound_1.createWebOutboundMessageEncoder)(name)),
+    __metadata("design:type", outbound_1.WebOutboundMessageEncoder)
+], BaseWebChannelHandler.prototype, "outboundMessageEncoder", void 0);
+__decorate([
+    (0, channel_1.ExtensionInject)((name) => (0, inbound_1.createWebInboundMessageEncoder)(name)),
+    __metadata("design:type", inbound_1.WebInboundMessageEncoder)
+], BaseWebChannelHandler.prototype, "inboundMessageEncoder", void 0);
 __decorate([
-    (0, common_1.Inject)(websocket_gateway_1.WebsocketGateway),
-    __metadata("design:type", websocket_gateway_1.WebsocketGateway)
-], BaseWebChannelHandler.prototype, "websocketGateway", void 0);
+    (0, channel_1.ExtensionInject)((name) => (0, inbound_1.createWebInboundEventDecoder)(name)),
+    __metadata("design:type", inbound_1.WebInboundEventDecoder)
+], BaseWebChannelHandler.prototype, "inboundEventDecoder", void 0);
 __decorate([
-    (0, common_1.Inject)(thread_service_1.ThreadService),
-    __metadata("design:type", thread_service_1.ThreadService)
-], BaseWebChannelHandler.prototype, "threadService", void 0);
+    (0, channel_1.ExtensionInject)(web_session_service_1.WebSessionService),
+    __metadata("design:type", web_session_service_1.WebSessionService)
+], BaseWebChannelHandler.prototype, "sessionService", void 0);
 __decorate([
-    (0, common_1.Inject)(channel_attachment_service_1.ChannelAttachmentService),
-    __metadata("design:type", channel_attachment_service_1.ChannelAttachmentService)
-], BaseWebChannelHandler.prototype, "channelAttachmentService", void 0);
+    (0, channel_1.ExtensionInject)(web_history_service_1.WebHistoryService),
+    __metadata("design:type", web_history_service_1.WebHistoryService)
+], BaseWebChannelHandler.prototype, "historyService", void 0);
 __decorate([
     (0, event_emitter_1.OnEvent)('hook:websocket:connection', { async: true }),
     __metadata("design:type", Function),
@@ -673,7 +479,7 @@ __decorate([
 ], BaseWebChannelHandler.prototype, "broadcastError", null);
 BaseWebChannelHandler = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [String])
+    __metadata("design:paramtypes", [String, Function])
 ], BaseWebChannelHandler);
 exports.default = BaseWebChannelHandler;
 //# sourceMappingURL=base-web-channel.js.map