@zohoim/client-sdk 1.0.0-poc8 → 1.0.0-poc80

package/es/frameworks/sdk/bots/BotSDK.js

@@ -0,0 +1,30 @@
+import { BotService } from "../../../application/services";
+import { BotRepository } from "../../../infrastructure/repositories";
+
+class BotSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      botAPI,
+      botAdapter
+    } = config;
+    const botRepository = new BotRepository({
+      botAPI,
+      botAdapter
+    }).toJSON();
+    const botService = new BotService({
+      botRepository
+    }).toJSON();
+    this.services = { ...botService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default BotSDK;

package/es/frameworks/sdk/bots/index.js

@@ -0,0 +1,2 @@
+import BotSDK from "./BotSDK";
+export { BotSDK };

package/es/frameworks/sdk/channels/ChannelSDK.js

@@ -0,0 +1,37 @@
+import { ChannelAgentService, ChannelService } from "../../../application/services";
+import { ChannelAgentRepository, ChannelRepository } from "../../../infrastructure/repositories";
+export default class ChannelSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      channelAPI,
+      channelAdapter,
+      channelAgentAPI,
+      channelAgentAdapter
+    } = config;
+    const channelAgentRepository = new ChannelAgentRepository({
+      channelAgentAPI,
+      channelAgentAdapter
+    }).toJSON();
+    const channelRepository = new ChannelRepository({
+      channelAPI,
+      channelAdapter
+    }).toJSON();
+    const channelService = new ChannelService({
+      channelRepository
+    }).toJSON();
+    const channelAgentService = new ChannelAgentService({
+      channelAgentRepository
+    }).toJSON();
+    this.services = { ...channelService,
+      agents: channelAgentService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}

package/es/frameworks/sdk/channels/index.js

@@ -0,0 +1,2 @@
+import ChannelSDK from "./ChannelSDK";
+export { ChannelSDK };

package/es/frameworks/sdk/contacts/ContactSDK.js

@@ -0,0 +1,30 @@
+import { ContactService } from "../../../application/services";
+import { ContactRepository } from "../../../infrastructure/repositories";
+
+class ContactSDK {
+  constructor(_ref) {
+    const {
+      config
+    } = _ref;
+    const {
+      contactAPI,
+      contactAdapter
+    } = config;
+    const contactRepository = new ContactRepository({
+      contactAPI,
+      contactAdapter
+    }).toJSON();
+    const contactService = new ContactService({
+      contactRepository
+    }).toJSON();
+    this.services = { ...contactService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default ContactSDK;

package/es/frameworks/sdk/contacts/index.js

@@ -0,0 +1,2 @@
+import ContactSDK from "./ContactSDK";
+export { ContactSDK };

package/es/frameworks/sdk/index.js

@@ -0,0 +1,2 @@
+import IMSDK from "./IMSDK";
+export { IMSDK };

package/es/frameworks/sdk/messages/MessageSDK.js

@@ -0,0 +1,32 @@
+import { MessageService } from "../../../application/services";
+import { MessageRepository } from "../../../infrastructure/repositories";
+
+class MessageSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      messageAPI,
+      messageAdapter,
+      messageWithSessionAdapter
+    } = config;
+    const messageRepository = new MessageRepository({
+      messageAPI,
+      messageAdapter,
+      messageWithSessionAdapter
+    }).toJSON();
+    const messageService = new MessageService({
+      messageRepository
+    }).toJSON();
+    this.services = { ...messageService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default MessageSDK;

package/es/frameworks/sdk/messages/index.js

@@ -0,0 +1,2 @@
+import MessageSDK from "./MessageSDK";
+export { MessageSDK };

package/es/frameworks/sdk/sessions/SessionSDK.js

@@ -0,0 +1,34 @@
+import { SessionService } from "../../../application/services";
+import { SessionRepository } from "../../../infrastructure/repositories";
+
+class SessionSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      sessionAPI,
+      sessionAdapter,
+      attachmentAdapter,
+      messageAdapter
+    } = config;
+    const sessionRepository = new SessionRepository({
+      sessionAPI,
+      sessionAdapter,
+      attachmentAdapter,
+      messageAdapter
+    }).toJSON();
+    const sessionService = new SessionService({
+      sessionRepository
+    }).toJSON();
+    this.services = { ...sessionService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default SessionSDK;

package/es/frameworks/sdk/sessions/index.js

@@ -0,0 +1,2 @@
+import SessionSDK from "./SessionSDK";
+export { SessionSDK };

package/es/index.js

@@ -1,4 +1,12 @@
-export * from './domain/entities';
-export * from './domain/interfaces';
-export * from './domain/services';
-export * from './sdk';
+// domain
+export * from "./domain/dto";
+export * from "./domain/entities";
+export * from "./domain/enum";
+export * from "./domain/interfaces"; // infrastructure
+
+export * from "./infrastructure/api"; // frameworks
+
+export * from "./frameworks/sdk"; // core
+
+export * from "./core/constants";
+export { ResponseUtils } from "./core/utils";

package/es/infrastructure/adapters/agents/AgentAdapter.js

@@ -0,0 +1,28 @@
+import { AdapterError } from "../../../core/errors";
+import { Agent } from "../../../domain/entities";
+import { ActorType } from "../../../domain/enum";
+import { IAdapter } from "../../../domain/interfaces";
+export default class AgentAdapter extends IAdapter {
+  adapt(agentData) {
+    if (!agentData) {
+      throw new AdapterError('Agent data is required');
+    }
+
+    try {
+      return new Agent({
+        id: agentData.id,
+        firstName: agentData.firstName,
+        lastName: agentData.lastName,
+        email: agentData.email,
+        zuid: agentData.zuid,
+        status: agentData.status,
+        role: agentData.role,
+        photoURL: agentData.photoURL,
+        type: [ActorType.AGENT]
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt Agent: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/agents/index.js

@@ -0,0 +1,2 @@
+import AgentAdapter from "./AgentAdapter";
+export { AgentAdapter };

package/es/infrastructure/adapters/attachments/AttachmentAdapter.js

@@ -0,0 +1,25 @@
+import { AdapterError } from "../../../core/errors";
+import { Attachment } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class AttachmentAdapter extends IAdapter {
+  adapt(attachmentData) {
+    if (!attachmentData) {
+      throw new AdapterError('Attachment data is required');
+    }
+
+    try {
+      return new Attachment({
+        id: attachmentData.id,
+        name: attachmentData.name,
+        type: attachmentData.type,
+        createdTime: attachmentData.createdTime,
+        size: attachmentData.size,
+        url: attachmentData.url,
+        status: attachmentData.status
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt attachment: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/attachments/index.js

@@ -0,0 +1,2 @@
+import AttachmentAdapter from "./AttachmentAdapter";
+export { AttachmentAdapter };

package/es/infrastructure/adapters/bots/BotAdapter.js

@@ -0,0 +1,25 @@
+import { AdapterError } from "../../../core/errors";
+import { Bot } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class BotAdapter extends IAdapter {
+  adapt(botData) {
+    if (!botData) {
+      throw new AdapterError('Bot data is required');
+    }
+
+    try {
+      return new Bot({
+        id: botData.id,
+        botServiceType: botData.botService.id,
+        name: botData.name,
+        isActive: botData.isActive,
+        createdTime: botData.createdTime,
+        photoURL: botData.logoURL,
+        createdBy: botData.createdBy
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt bot: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/bots/index.js

@@ -0,0 +1,2 @@
+import BotAdapter from "./BotAdapter";
+export { BotAdapter };

package/es/infrastructure/adapters/channels/ChannelAdapter.js

@@ -0,0 +1,29 @@
+import { AdapterError } from "../../../core/errors";
+import { Channel } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class ChannelAdapter extends IAdapter {
+  adapt(rawChannel) {
+    if (!rawChannel) {
+      throw new AdapterError('Channel data is required');
+    }
+
+    try {
+      return new Channel({
+        id: rawChannel.id,
+        integrationService: rawChannel.integrationService,
+        name: rawChannel.name,
+        defaultBotId: rawChannel.defaultBotId,
+        isActive: rawChannel.isActive,
+        createdTime: rawChannel.createdTime,
+        accountName: rawChannel.accountName,
+        isSubscribed: rawChannel.isSubscribed,
+        createdBy: rawChannel.createdBy,
+        isOwner: rawChannel.isOwner,
+        photoURL: rawChannel.logoURL
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt channel: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/channels/ChannelAgentAdapter.js

@@ -0,0 +1,49 @@
+import { AdapterError } from "../../../core/errors";
+import { Agent } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class ChannelAgentAdapter extends IAdapter {
+  /**
+   * Adapts channel agent data to Agent entity
+   * @param {Object} channelAgent - Channel agent data to adapt
+   * @returns {Object} Adapted agent data
+   * @throws {AdapterError} When adaptation fails
+   */
+  adapt(channelAgent) {
+    if (!channelAgent) {
+      throw new AdapterError('Channel agent data is required');
+    }
+
+    try {
+      const {
+        id,
+        name,
+        email,
+        photoURL,
+        zuid,
+        type
+      } = new Agent({
+        id: channelAgent.id,
+        name: channelAgent.name,
+        email: channelAgent.email,
+        photoURL: channelAgent.photoURL,
+        zuid: channelAgent.zuid,
+        type: channelAgent.type,
+        firstName: null,
+        lastName: null,
+        status: null,
+        role: null
+      }).toJSON();
+      return {
+        id,
+        name,
+        email,
+        photoURL,
+        zuid,
+        type
+      };
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt channel agent: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/channels/index.js

@@ -0,0 +1,3 @@
+import ChannelAdapter from "./ChannelAdapter";
+import ChannelAgentAdapter from "./ChannelAgentAdapter";
+export { ChannelAgentAdapter, ChannelAdapter };

package/es/infrastructure/adapters/contacts/ContactAdapter.js

@@ -0,0 +1,24 @@
+import { AdapterError } from "../../../core/errors";
+import { Contact } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class ContactAdapter extends IAdapter {
+  adapt(contactData) {
+    if (!contactData) {
+      throw new AdapterError('Contact data is required');
+    }
+
+    try {
+      return new Contact({
+        id: contactData.id,
+        name: contactData.name,
+        photoURL: contactData.photoURL,
+        email: contactData.email,
+        mobile: contactData.mobile,
+        phone: contactData.phone
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt Contact: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/contacts/index.js

@@ -0,0 +1,2 @@
+import ContactAdapter from "./ContactAdapter";
+export { ContactAdapter };

package/es/infrastructure/adapters/index.js

@@ -0,0 +1,7 @@
+export * from "./channels";
+export * from "./sessions";
+export * from "./bots";
+export * from "./attachments";
+export * from "./messages";
+export * from "./agents";
+export * from "./contacts";

package/es/infrastructure/adapters/messages/MessageAdapter.js

@@ -0,0 +1,41 @@
+import { AdapterError } from "../../../core/errors";
+import { Message } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class MessageAdapter extends IAdapter {
+  adapt(messageData) {
+    if (!messageData) {
+      throw new AdapterError('Message data is required');
+    }
+
+    try {
+      return new Message({
+        id: messageData.id,
+        sessionId: messageData.sessionId,
+        displayMessage: messageData.displayMessage,
+        statusUpdatedTime: messageData.statusUpdatedTime,
+        actor: messageData.actor,
+        direction: messageData.direction,
+        createdTime: messageData.createdTime,
+        index: messageData.index,
+        replyToMessage: messageData.replyToMessage,
+        status: messageData.status,
+        info: messageData.info,
+        location: messageData.location,
+        externalInfo: messageData.externalInfo,
+        layout: messageData.layout,
+        action: messageData.action,
+        meta: messageData.meta,
+        contentType: messageData.contentType,
+        fullContentURL: messageData.fullContentURL,
+        attachment: messageData.attachment,
+        template: messageData.template,
+        type: messageData.type,
+        isRead: messageData.isRead,
+        article: messageData.article
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt message: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/messages/MessageWithSessionAdapter.js

@@ -0,0 +1,23 @@
+import { AdapterError } from "../../../core/errors";
+import { MessageWithSession } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+import { MessageAdapter, SessionAdapter } from "../index";
+export default class MessageWithSessionAdapter extends IAdapter {
+  adapt(messageData) {
+    if (!messageData) {
+      throw new AdapterError('Message With Session data is required');
+    }
+
+    const message = new MessageAdapter().adapt(messageData);
+    const session = new SessionAdapter().adapt(messageData.session);
+
+    try {
+      return new MessageWithSession({ ...message,
+        session
+      }).toJSON();
+    } catch (error) {
+      throw new Error(`Failed to adapt message with session: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/messages/index.js

@@ -0,0 +1,2 @@
+import MessageAdapter from "./MessageAdapter";
+export { MessageAdapter };

package/es/infrastructure/adapters/sessions/SessionAdapter.js

@@ -0,0 +1,36 @@
+import { AdapterError } from "../../../core/errors";
+import { Session } from "../../../domain/entities";
+import { IAdapter } from "../../../domain/interfaces";
+export default class SessionAdapter extends IAdapter {
+  adapt(sessionData) {
+    if (!sessionData) {
+      throw new AdapterError('Session data is required');
+    }
+
+    try {
+      return new Session({
+        id: sessionData.id,
+        channelId: sessionData.channelId,
+        status: sessionData.status,
+        createdTime: sessionData.createdTime,
+        agentId: sessionData.agentId,
+        botId: sessionData.botId,
+        actor: sessionData.actor,
+        subject: sessionData.subject,
+        messagesCount: sessionData.messagesCount,
+        agentLastActiveTime: sessionData.agentLastActiveTime,
+        contactLastActiveTime: sessionData.contactLastActiveTime,
+        lastActiveTime: sessionData.lastActiveTime,
+        unreadMessagesCount: sessionData.unreadMessagesCount,
+        integrationServiceId: sessionData.integrationServiceId,
+        replyStatus: sessionData.replyStatus,
+        contactId: sessionData.contactId,
+        meta: sessionData.meta,
+        assignee: sessionData.assignee
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt session: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/sessions/index.js

@@ -0,0 +1,2 @@
+import SessionAdapter from "./SessionAdapter";
+export { SessionAdapter };