@hexabot-ai/api 3.0.0-alpha.3 → 3.1.0-alpha.0

package/src/channel/channel.service.ts

@@ -4,14 +4,17 @@
  * Full terms: see LICENSE.md.
  */
 
-import { Injectable, UnauthorizedException } from '@nestjs/common';
+import {
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
 import { Request, Response } from 'express';
 
 import { SubscriberService } from '@/chat/services/subscriber.service';
-import { CONSOLE_CHANNEL_NAME } from '@/extensions/channels/console/settings';
-import { WEB_CHANNEL_NAME } from '@/extensions/channels/web/settings';
+import { CONSOLE_CHANNEL_NAME } from '@/extensions/channels/console/console-channel.settings';
+import { WEB_CHANNEL_NAME } from '@/extensions/channels/web/web-channel.settings';
 import { LoggerService } from '@/logger/logger.service';
-import { getSessionStore } from '@/utils/constants/session-store';
 import {
   SocketGet,
   SocketPost,
@@ -20,6 +23,7 @@ import { SocketReq } from '@/websocket/decorators/socket-req.decorator';
 import { SocketRes } from '@/websocket/decorators/socket-res.decorator';
 import { SocketRequest } from '@/websocket/utils/socket-request';
 import { SocketResponse } from '@/websocket/utils/socket-response';
+import { WorkflowService } from '@/workflow/services/workflow.service';
 
 import ChannelHandler from './lib/Handler';
 import { ChannelName } from './types';
@@ -31,6 +35,7 @@ export class ChannelService {
   constructor(
     private readonly logger: LoggerService,
     private readonly subscriberService: SubscriberService,
+    private readonly workflowService: WorkflowService,
   ) {}
 
   /**
@@ -91,25 +96,17 @@ export class ChannelService {
    * @param channel - The channel for which the request is being handled.
    * @param req - The HTTP request object.
    * @param res - The HTTP response object.
+   * @param workflowId - Optional workflow identifier to target execution.
    * @returns A promise that resolves when the handler has processed the request.
    */
-  async handle(channel: string, req: Request, res: Response): Promise<void> {
-    const handler = this.getChannelHandler(`${channel}-channel`);
-    handler.handle(req, res);
-  }
-
-  /**
-   * Handles a download request for a specific channel.
-   *
-   * @param channel - The channel for which the request is being handled.
-   * @param token - The file JWT token.
-   * @param req - The HTTP express request object.
-   * @returns A promise that resolves a streamable if the signed url is valid.
-   */
-  async download(channel: string, token: string, req: Request) {
-    const handler = this.getChannelHandler(`${channel}-channel`);
-
-    return await handler.download(token, req);
+  async handle(
+    channel: string,
+    req: Request,
+    res: Response,
+    workflowId?: string,
+  ): Promise<void> {
+    const handler = this.getChannelHandler(channel);
+    handler.handle(req, res, workflowId);
   }
 
   /**
@@ -126,8 +123,9 @@ export class ChannelService {
   ) {
     this.logger.log('Channel notification (Web Socket) : ', req.method);
     const handler = this.getChannelHandler(WEB_CHANNEL_NAME);
+    const workflowId = await this.getValidatedWorkflowId(req);
 
-    return await handler.handle(req, res);
+    return await handler.handle(req, res, workflowId);
   }
 
   /**
@@ -158,52 +156,61 @@ export class ChannelService {
     }
 
     if (!req.session.web?.profile?.id) {
-      // Create test subscriber for the current user
-      const testSubscriber = await this.subscriberService.findOneOrCreate(
+      const profile = await this.subscriberService.updateOne(
+        req.session.passport.user.id,
         {
-          where: { foreign_id: req.session.passport.user.id },
-        },
-        {
-          foreign_id: req.session.passport.user.id,
-          first_name: req.session.passport.user.first_name || 'Anonymous',
-          last_name: req.session.passport.user.last_name || 'Anonymous',
-          locale: null,
-          language: null,
-          gender: null,
-          country: null,
-          labels: [],
-          assignedTo: null,
-          assignedAt: null,
-          lastvisit: new Date(),
-          retainedFrom: new Date(),
-          timezone: 0,
-          avatar: null,
           channel: {
             name: CONSOLE_CHANNEL_NAME,
             data: { isSocket: true },
           },
-          context: { vars: {} },
+          lastvisit: new Date(),
+          retainedFrom: new Date(),
+          foreignId: req.session.passport.user.id,
         },
       );
 
       // Update session (end user is both a user + subscriber)
       req.session.web = {
-        profile: testSubscriber,
-        isSocket: true,
-        messageQueue: [],
-        polling: false,
+        profile,
       };
-
-      // @TODO: temporary fix until it's fixed properly: https://github.com/Hexastack/Hexabot/issues/578
-      getSessionStore().set(req.session.id, req.session, (err) => {
-        if (err) {
-          this.logger.warn('Unable to store WS Console session', err);
-        }
-      });
     }
 
     const handler = this.getChannelHandler(CONSOLE_CHANNEL_NAME);
+    const workflowId = await this.getValidatedWorkflowId(req);
+
+    return await handler.handle(req, res, workflowId);
+  }
+
+  private getWorkflowIdFromSocketQuery(req: SocketRequest): string | undefined {
+    const rawWorkflowId = req.query.workflow_id;
+    const workflowId = Array.isArray(rawWorkflowId)
+      ? rawWorkflowId[0]
+      : rawWorkflowId;
+
+    if (typeof workflowId !== 'string') {
+      return undefined;
+    }
+
+    const normalizedWorkflowId = workflowId.trim();
+
+    return normalizedWorkflowId.length > 0 ? normalizedWorkflowId : undefined;
+  }
+
+  private async getValidatedWorkflowId(
+    req: SocketRequest,
+  ): Promise<string | undefined> {
+    const workflowId = this.getWorkflowIdFromSocketQuery(req);
+
+    if (!workflowId) {
+      return undefined;
+    }
+
+    const workflow = await this.workflowService.findOne(workflowId);
+
+    if (!workflow) {
+      throw new NotFoundException(`Workflow with ID ${workflowId} not found`);
+    }
 
-    return await handler.handle(req, res);
+    return workflowId;
   }
 }

package/src/channel/index.ts

@@ -6,16 +6,20 @@
 
 export * from './channel.controller';
 
-export * from './channel.middleware';
-
 export * from './channel.module';
 
 export * from './channel.service';
 
-export * from './lib/EventWrapper';
+export * from './lib/inbound-events';
+
+export * from './lib/outbound';
 
 export * from './lib/Handler';
 
+export * from './services/channel-attachment.service';
+
+export * from './services/channel-download.service';
+
 export * from './types';
 
 export * from './webhook.controller';

package/src/channel/lib/Handler.ts

@@ -4,22 +4,14 @@
  * Full terms: see LICENSE.md.
  */
 
-import path from 'path';
-
-import {
-  ForbiddenException,
-  Inject,
-  Injectable,
-  NotFoundException,
-  OnModuleInit,
-} from '@nestjs/common';
-import { JwtService, JwtSignOptions, JwtVerifyOptions } from '@nestjs/jwt';
-import { plainToClass } from 'class-transformer';
-import { NextFunction, Request, Response } from 'express';
+import { Inject, Injectable, OnModuleInit, Type } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { Request, Response } from 'express';
 import mime from 'mime';
 import { v4 as uuidv4 } from 'uuid';
 
-import { AttachmentOrmEntity } from '@/attachment/entities/attachment.entity';
+import { Attachment } from '@/attachment/dto/attachment.dto';
 import { AttachmentService } from '@/attachment/services/attachment.service';
 import {
   AttachmentAccess,
@@ -27,27 +19,18 @@ import {
   AttachmentFile,
   AttachmentResourceRef,
 } from '@/attachment/types';
+import { MessageInboundEvent } from '@/channel/lib/inbound-events';
 import { SubscriberCreateDto } from '@/chat/dto/subscriber.dto';
-import { AttachmentRef } from '@/chat/types/attachment';
-import {
-  IncomingMessageType,
-  StdEventType,
-  StdOutgoingEnvelope,
-  StdOutgoingMessage,
-} from '@/chat/types/message';
-import { config } from '@/config';
-import { LoggerService } from '@/logger/logger.service';
+import { StdOutgoingEnvelope } from '@/chat/types/message';
+import type { ActionOptions } from '@/chat/types/options';
+import { I18nService } from '@/i18n';
 import { SettingService } from '@/setting/services/setting.service';
 import { Extension } from '@/utils/generics/extension';
-import { buildURL } from '@/utils/helpers/URL';
-import { HyphenToUnderscore } from '@/utils/types/extension';
 import { SocketRequest } from '@/websocket/utils/socket-request';
 import { SocketResponse } from '@/websocket/utils/socket-response';
 
 import { ChannelService } from '../channel.service';
-import { ChannelName, ChannelSetting } from '../types';
-
-import EventWrapper from './EventWrapper';
+import { ChannelName } from '../types';
 
 @Injectable()
 export default abstract class ChannelHandler<
@@ -56,30 +39,26 @@ export default abstract class ChannelHandler<
   extends Extension
   implements OnModuleInit
 {
-  private readonly settings: ChannelSetting<N>[];
+  @Inject(I18nService)
+  protected readonly i18n: I18nService;
+
+  @Inject(EventEmitter2)
+  protected readonly eventEmitter: EventEmitter2;
 
   @Inject(AttachmentService)
   public readonly attachmentService: AttachmentService;
 
-  @Inject(JwtService)
-  protected readonly jwtService: JwtService;
+  @Inject(SettingService)
+  protected readonly settingService: SettingService;
 
-  protected readonly jwtSignOptions: JwtSignOptions = {
-    secret: config.parameters.signedUrl.secret,
-    expiresIn: config.parameters.signedUrl.expiresIn,
-    algorithm: 'HS256',
-    encoding: 'utf-8',
-  };
+  @Inject(ChannelService)
+  protected readonly channelService: ChannelService;
 
-  constructor(
-    name: N,
-    protected readonly settingService: SettingService,
-    private readonly channelService: ChannelService,
-    protected readonly logger: LoggerService,
-  ) {
+  @Inject(ModuleRef)
+  private readonly moduleRef: ModuleRef;
+
+  constructor(name: N) {
     super(name);
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    this.settings = require(path.join(this.getPath(), 'settings')).default;
   }
 
   getName() {
@@ -92,30 +71,23 @@ export default abstract class ChannelHandler<
       this.getName(),
       this as unknown as ChannelHandler<N>,
     );
-    this.setup();
   }
 
-  async setup() {
-    await this.settingService.seedIfNotExist(this.getName(), this.settings);
-    this.init();
+  protected async createModuleRef<T>(provider: Type<T>): Promise<T> {
+    return await this.moduleRef.create(provider);
   }
 
   /**
    * Returns the channel's settings
    * @returns Channel's settings
    */
-  async getSettings<S extends string = HyphenToUnderscore<N>>() {
+  async getSettings<S extends string = N>() {
     const settings = await this.settingService.getSettings();
 
     // @ts-expect-error workaround typing
-    return settings[this.getNamespace() as keyof Settings] as Settings[S];
+    return settings[this.getName() as keyof Settings] as Settings[S];
   }
 
-  /**
-   * Perform any initialization needed
-   */
-  abstract init(): void;
-
   /**
    * Process incoming channel data via POST/GET methods
    *
@@ -125,72 +97,7 @@ export default abstract class ChannelHandler<
   abstract handle(
     req: Request | SocketRequest,
     res: Response | SocketResponse,
-  ): any;
-
-  /**
-   * Format a text message that will be sent to the channel
-   *
-   * @param message - A text to be sent to the end user
-   * @param options - might contain additional settings
-   * @returns {Object} - A text message in the channel specific format
-   */
-  abstract _textFormat(message: StdOutgoingMessage, options?: any): any;
-
-  /**
-   * Format a text + quick replies message that can be sent to the channel
-   *
-   * @param message - A text + quick replies to be sent to the end user
-   * @param options - might contain additional settings
-   * @returns {Object} - A quick replies message in the channel specific format
-   */
-  abstract _quickRepliesFormat(message: StdOutgoingMessage, options?: any): any;
-
-  /**
-   * From raw buttons, construct a channel understable message containing those buttons
-   *
-   * @param message - A text + buttons to be sent to the end user
-   * @param options - Might contain additional settings
-   * @returns {Object} - A buttons message in the format required by the channel
-   */
-  abstract _buttonsFormat(
-    message: StdOutgoingMessage,
-    options?: any,
-    ...args: any
-  ): any;
-
-  /**
-   * Format an attachment + quick replies message that can be sent to the channel
-   *
-   * @param message - An attachment + quick replies to be sent to the end user
-   * @param options - Might contain additional settings
-   * @returns {Object} - An attachment message in the format required by the channel
-   */
-  abstract _attachmentFormat(message: StdOutgoingMessage, options?: any): any;
-
-  /**
-   * Format a list of elements
-   *
-   * @param message - Contains elements to be sent to the end user
-   * @param options - Might contain additional settings
-   * @returns {Object} - A ready to be sent list template message in the format required by the channel
-   */
-  abstract _listFormat(
-    message: StdOutgoingMessage,
-    options: any,
-    ...args: any
-  ): any;
-
-  /**
-   * Format a carousel message
-   * @param message - Contains elements to be sent to the end user
-   * @param options - Might contain additional settings
-   * @returns {Object} - A carousel ready to be sent in the format required by the channel
-   
-   */
-  abstract _carouselFormat(
-    message: StdOutgoingMessage,
-    options: any,
-    ...args: any
+    workflowId?: string,
   ): any;
 
   /**
@@ -198,15 +105,13 @@ export default abstract class ChannelHandler<
    * @param event - Incoming event/message being responded to
    * @param envelope - The message to be sent {format, message}
    * @param options - Might contain additional settings
-   * @param context - Contextual data
    * @returns {Promise} - The channel's response, otherwise an error
    
    */
   abstract sendMessage(
-    event: EventWrapper<any, any, N>,
+    event: MessageInboundEvent<N>,
     envelope: StdOutgoingEnvelope,
-    options: any,
-    context: any,
+    options: ActionOptions,
   ): Promise<{ mid: string }>;
 
   /**
@@ -216,7 +121,7 @@ export default abstract class ChannelHandler<
    * @returns An attachment array
    */
   getMessageAttachments?(
-    event: EventWrapper<any, any, N>,
+    event: MessageInboundEvent<N>,
   ): Promise<AttachmentFile[]>;
 
   /**
@@ -225,7 +130,7 @@ export default abstract class ChannelHandler<
    * @returns {Promise<Subscriber>} - The channel's response, otherwise an error
    */
   getSubscriberAvatar?(
-    event: EventWrapper<any, any, N>,
+    event: MessageInboundEvent<N>,
   ): Promise<AttachmentFile | undefined>;
 
   /**
@@ -236,7 +141,7 @@ export default abstract class ChannelHandler<
    * @returns {Promise<Subscriber>} - The channel's response, otherwise an error
    */
   async getUserData(
-    event: EventWrapper<any, any, N>,
+    event: MessageInboundEvent<N>,
   ): Promise<SubscriberCreateDto> {
     return await this.getSubscriberData(event);
   }
@@ -248,7 +153,7 @@ export default abstract class ChannelHandler<
    * @returns {Promise<Subscriber>} - The channel's response, otherwise an error
    */
   abstract getSubscriberData(
-    event: EventWrapper<any, any, N>,
+    event: MessageInboundEvent<N>,
   ): Promise<SubscriberCreateDto>;
 
   /**
@@ -256,88 +161,32 @@ export default abstract class ChannelHandler<
    *
    * @returns Resolves the promise once attachments are fetched and stored
    */
-  async persistMessageAttachments(event: EventWrapper<any, any, N>) {
-    if (
-      event._adapter.eventType === StdEventType.message &&
-      event._adapter.messageType === IncomingMessageType.attachments &&
-      this.getMessageAttachments
-    ) {
-      const metadatas = await this.getMessageAttachments(event);
-      const subscriber = event.getSender();
-      event._adapter.attachments = await Promise.all(
-        metadatas.map(({ file, name, type, size }) => {
-          return this.attachmentService.store(file, {
-            name: `${name ? `${name}-` : ''}${uuidv4()}.${mime.extension(type)}`,
-            type,
-            size,
-            resourceRef: AttachmentResourceRef.MessageAttachment,
-            access: AttachmentAccess.Private,
-            createdByRef: AttachmentCreatedByRef.Subscriber,
-            createdBy: subscriber.id,
-          });
-        }),
-      );
+  async persistMessageAttachments(
+    event: MessageInboundEvent<N> & {
+      setPersistedAttachments(attachments: Attachment[]): void;
+    },
+  ) {
+    if (!this.getMessageAttachments) {
+      return;
     }
-  }
-
-  /**
-   * Custom channel middleware
-   * @param req
-   * @param res
-   * @param next
-   */
-  async middleware(
-    _req: Request,
-    _res: Response,
-    next: NextFunction,
-  ): Promise<unknown> {
-    // Do nothing, override in channel
-    return next();
-  }
-
-  /**
-   * Generates a signed URL for downloading an attachment.
-   *
-   * This function creates a signed URL for a given attachment using a JWT token.
-   * The signed URL includes the attachment name and a token as query parameters.
-   *
-   * @param attachment The attachment ID or object to generate a signed URL for.
-   * @return A signed URL string for downloading the specified attachment.
-   */
-  public async getPublicUrl(attachment: AttachmentRef | AttachmentOrmEntity) {
-    const [name, _suffix] = this.getName().split('-');
-    if (attachment && 'id' in attachment) {
-      if (!attachment || !attachment.id) {
-        this.logger.warn('Unable to build public URL: Empty attachment ID');
 
-        return buildURL(config.apiBaseUrl, `/webhook/${name}/not-found`);
-      }
-
-      const resource = await this.attachmentService.findOne(attachment.id);
-
-      if (!resource) {
-        this.logger.warn('Unable to find attachment sending fallback image');
-
-        return buildURL(config.apiBaseUrl, `/webhook/${name}/not-found`);
-      }
-
-      const token = this.jwtService.sign({ ...resource }, this.jwtSignOptions);
-
-      return buildURL(
-        config.apiBaseUrl,
-        `/webhook/${name}/download/${resource.name}?t=${encodeURIComponent(token)}`,
-      );
-    } else if ('url' in attachment && attachment.url) {
-      // In case the url is external
-      return attachment.url;
-    } else {
-      this.logger.warn(
-        'Unable to resolve the attachment public URL.',
-        attachment,
-      );
+    const metadatas = await this.getMessageAttachments(event);
+    const subscriber = event.getInitiator();
+    const attachments = await Promise.all(
+      metadatas.map(({ file, name, type, size }) => {
+        return this.attachmentService.store(file, {
+          name: `${name ? `${name}-` : ''}${uuidv4()}.${mime.extension(type)}`,
+          type,
+          size,
+          resourceRef: AttachmentResourceRef.MessageAttachment,
+          access: AttachmentAccess.Private,
+          createdByRef: AttachmentCreatedByRef.Subscriber,
+          createdBy: subscriber.id,
+        });
+      }),
+    );
 
-      return buildURL(config.apiBaseUrl, `/webhook/${name}/not-found`);
-    }
+    event.setPersistedAttachments(attachments);
   }
 
   /**
@@ -349,47 +198,7 @@ export default abstract class ChannelHandler<
    * @param req - The HTTP express request object.
    * @return True, if requester is authorized to download the attachment
    */
-  public async hasDownloadAccess(
-    attachment: AttachmentOrmEntity,
-    _req: Request,
-  ) {
+  public async hasDownloadAccess(attachment: Attachment, _req: Request) {
     return attachment.access === AttachmentAccess.Public;
   }
-
-  /**
-   * Downloads an attachment using a signed token.
-   *
-   * This function verifies the provided token and retrieves the corresponding
-   * attachment as a streamable file. If the verification fails or the attachment
-   * cannot be located, it throws a NotFoundException.
-   *
-   * @param token The signed token used to verify and locate the attachment.
-   * @param req - The HTTP express request object.
-   * @return A streamable file of the attachment.
-   */
-  public async download(token: string, req: Request) {
-    try {
-      const {
-        exp: _exp,
-        iat: _iat,
-        ...result
-      } = this.jwtService.verify(
-        token,
-        this.jwtSignOptions as JwtVerifyOptions,
-      );
-      const attachment = plainToClass(AttachmentOrmEntity, result);
-      // Check access
-      const canDownload = await this.hasDownloadAccess(attachment, req);
-      if (!canDownload) {
-        throw new ForbiddenException(
-          'You are not authorized to download the attachment',
-        );
-      }
-
-      return await this.attachmentService.download(attachment);
-    } catch (err) {
-      this.logger.error('Failed to download attachment', err);
-      throw new NotFoundException('Unable to locate attachment');
-    }
-  }
 }

package/src/channel/lib/__test__/common.mock.ts

@@ -20,7 +20,6 @@ import {
   StdOutgoingQuickRepliesMessage,
   StdOutgoingTextMessage,
 } from '@/chat/types/message';
-import { QuickReplyType } from '@/chat/types/quick-reply';
 
 export const textMessage: StdOutgoingTextMessage = {
   text: 'Hello World',
@@ -30,12 +29,10 @@ export const quickRepliesMessage: StdOutgoingQuickRepliesMessage = {
   text: 'Choose one option',
   quickReplies: [
     {
-      content_type: QuickReplyType.text,
       title: 'First option',
       payload: 'first_option',
     },
     {
-      content_type: QuickReplyType.text,
       title: 'Second option',
       payload: 'second_option',
     },
@@ -94,7 +91,7 @@ const attachment: AttachmentOrmEntity = Object.assign(
         id: 'any-channel-attachment-id',
       },
     },
-    resourceRef: AttachmentResourceRef.BlockAttachment,
+    resourceRef: AttachmentResourceRef.MessageAttachment,
     access: AttachmentAccess.Public,
     createdByRef: AttachmentCreatedByRef.User,
     createdBy: null,
@@ -168,7 +165,6 @@ export const attachmentMessage: StdOutgoingAttachmentMessage = {
   },
   quickReplies: [
     {
-      content_type: QuickReplyType.text,
       title: 'Next >',
       payload: 'NEXT',
     },

package/src/channel/lib/__test__/subscriber.mock.ts

@@ -10,9 +10,9 @@ import { modelInstance } from './base.mock';
 import { customerLabelsMock } from './label.mock';
 
 export const subscriberInstance: Subscriber = {
-  foreign_id: 'foreign-id-for-jhon-doe',
-  first_name: 'John',
-  last_name: 'Doe',
+  foreignId: 'foreign-id-for-jhon-doe',
+  firstName: 'John',
+  lastName: 'Doe',
   language: 'fr',
   locale: 'fr_FR',
   gender: 'male',
@@ -23,11 +23,10 @@ export const subscriberInstance: Subscriber = {
   lastvisit: new Date(),
   retainedFrom: new Date(),
   channel: {
-    name: 'web-channel',
+    name: 'web',
   },
   labels: [],
   avatar: null,
-  context: {},
   ...modelInstance,
 };