@zohoim/client-sdk 1.0.0-poc1 → 1.0.0-poc10

package/es/config/urls/channels/channel-agents-api-url.js

@@ -0,0 +1,11 @@
+import { HTTP_METHODS, IM_API_PREFIX } from '../../../core/constants';
+import { GetChannelAgentsRequest } from '../../../infrastructure/interfaces/api';
+const BASE_URL = `${IM_API_PREFIX}/channels/:channelId/agents`;
+const CHANNEL_AGENTS_API_URLS = {
+  LIST: {
+    url: BASE_URL,
+    method: HTTP_METHODS.GET,
+    ...GetChannelAgentsRequest
+  }
+};
+export default CHANNEL_AGENTS_API_URLS;

package/es/config/urls/channels/index.js

@@ -0,0 +1,2 @@
+import CHANNEL_AGENTS_API_URLS from './channel-agents-api-url';
+export { CHANNEL_AGENTS_API_URLS };

package/es/config/urls/index.js

@@ -0,0 +1 @@
+export * from './channels';

package/es/config/urls/sessions/sessions-api-url.js

@@ -0,0 +1,12 @@
+import { UpdateSessionAssigneeRequest } from '../../../infrastructure/interfaces/api';
+import { HTTP_METHODS, IM_API_PREFIX } from '../../../core/constants';
+const BASE_URL = `${IM_API_PREFIX}/sessions`;
+const SINGLE_SESSION_URL = `${BASE_URL}/:sessionId`;
+const SESSIONS_API_URLS = {
+  UPDATE_SESSION_ASSIGNEE: {
+    url: SINGLE_SESSION_URL,
+    method: HTTP_METHODS.PATCH,
+    ...UpdateSessionAssigneeRequest
+  }
+};
+export default SESSIONS_API_URLS;

package/es/core/constants/HttpMethods.js

@@ -0,0 +1,8 @@
+const HTTP_METHODS = {
+  GET: 'GET',
+  POST: 'POST',
+  PUT: 'PUT',
+  PATCH: 'PATCH',
+  DELETE: 'DELETE'
+};
+export default HTTP_METHODS;

package/es/core/constants/ModuleNames.js

@@ -0,0 +1,5 @@
+const ModuleNames = {
+  CHANNELS: 'channels',
+  SESSIONS: 'sessions'
+};
+export default ModuleNames;

package/es/core/constants/index.js

@@ -0,0 +1,4 @@
+import HTTP_METHODS from './HTTPMethods';
+import ModuleNames from './ModuleNames';
+const IM_API_PREFIX = '/api/v1';
+export { ModuleNames, IM_API_PREFIX, HTTP_METHODS };

package/es/core/errors/AdapterError.js

@@ -0,0 +1,7 @@
+export default class AdapterError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AdapterError';
+  }
+
+}

package/es/core/errors/index.js

@@ -0,0 +1,3 @@
+import AdapterError from './AdapterError';
+import ValidationError from './ValidationError';
+export { ValidationError, AdapterError };

package/es/core/utils/index.js

@@ -0,0 +1,2 @@
+import { validateSchema } from './validateSchema';
+export { validateSchema };

package/es/core/utils/validateSchema.js

@@ -0,0 +1,68 @@
+import { ValidationError } from '../errors';
+
+function validateSchemaKeys(schema, data) {
+  Object.keys(schema).forEach(key => {
+    if (!(key in data)) {
+      throw new ValidationError(`Key '${key}' is missing in the data`);
+    }
+  });
+}
+
+function validateRequiredCheck(_ref) {
+  let {
+    value,
+    rules,
+    path
+  } = _ref;
+
+  if (rules.required && !value) {
+    throw new ValidationError(rules.message || `${path} is required`);
+  }
+}
+
+function validateEnumCheck(_ref2) {
+  let {
+    value,
+    rules,
+    path
+  } = _ref2;
+
+  if (rules.enum && !rules.enum.includes(value)) {
+    throw new ValidationError(`${path} must be one of: ${rules.enum.join(', ')}`);
+  }
+}
+
+export const validateSchema = (schema, data) => {
+  const validate = function (schemaObj, dataObj) {
+    let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+    // Check if all schema keys exist in data
+    validateSchemaKeys(schemaObj, dataObj); // Validate each field
+
+    Object.entries(schemaObj).forEach(_ref3 => {
+      let [field, rules] = _ref3;
+      const value = dataObj[field];
+      const fieldPath = path ? `${path}.${field}` : field;
+      validateRequiredCheck({
+        value,
+        rules,
+        path: fieldPath
+      });
+
+      if (value !== null && value !== undefined) {
+        // Enum validation
+        validateEnumCheck({
+          value,
+          rules,
+          path: fieldPath
+        }); // Nested object validation
+
+        if (rules.type === 'object' && rules.schema) {
+          validate(rules.schema, value, fieldPath);
+        }
+      }
+    });
+    return dataObj;
+  };
+
+  return validate(schema, data);
+};

package/es/domain/entities/Actor/Actor.js

@@ -0,0 +1,23 @@
+import { validateSchema } from '../../../core/utils';
+import { ActorSchema } from '../../schema';
+export default class Actor {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema(ActorSchema, data);
+    this.data = {
+      name: validatedData.name,
+      type: validatedData.type,
+      photoURL: validatedData.photoURL,
+      extId: validatedData.extId,
+      id: validatedData.id,
+      email: validatedData.email,
+      botType: validatedData.botType
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Actor/index.js

@@ -1,2 +1,2 @@
-import ActorType from './ActorType';
-export { ActorType };
+import Actor from './Actor';
+export { Actor };

package/es/domain/entities/Agent/Agent.js

@@ -1,110 +1,21 @@
-import ValidationError from '../../errors/ValidationError';
-import ActorType from '../Actor/ActorType';
+import { validateSchema } from '../../../core/utils';
+import { AgentSchema } from '../../schema';
 export default class Agent {
   constructor() {
-    let {
-      id = '',
-      name = '',
-      email = '',
-      photoURL = '',
-      zuid = '',
-      type = ''
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    this.validateFields({
-      id,
-      email,
-      name,
-      zuid
-    });
-    this._id = id;
-    this._name = name;
-    this._email = email;
-    this._photoURL = photoURL;
-    this._zuid = zuid;
-    this.setType(type);
-  }
-
-  validateFields(_ref) {
-    let {
-      id,
-      email,
-      name,
-      zuid
-    } = _ref;
-    this.validateId(id);
-    this.validateEmail(email);
-    this.validateName(name);
-    this.validateZuid(zuid);
-  }
-
-  static validateId(id) {
-    if (!id) {
-      throw new ValidationError('Agent ID is required');
-    }
-  }
-
-  static validateEmail(email) {
-    if (!email) {
-      throw new ValidationError('Agent email is required');
-    }
-  }
-
-  static validateName(name) {
-    if (!name) {
-      throw new ValidationError('Agent name is required');
-    }
-  }
-
-  static validateZuid(zuid) {
-    if (!zuid) {
-      throw new ValidationError('Agent zuid is required');
-    }
-  }
-
-  static validateType(type) {
-    return type === ActorType.AGENT;
-  }
-
-  setType(type) {
-    if (!Agent.validateType(type)) {
-      throw new Error('Invalid actor type. Must be AGENT');
-    }
-
-    this._type = type;
-  }
-
-  get id() {
-    return this._id;
-  }
-
-  get name() {
-    return this._name;
-  }
-
-  get email() {
-    return this._email;
-  }
-
-  get photoURL() {
-    return this._photoURL;
-  }
-
-  get zuid() {
-    return this._zuid;
-  }
-
-  get type() {
-    return this._type;
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema(AgentSchema, data);
+    this.data = {
+      id: validatedData.id,
+      name: validatedData.name,
+      email: validatedData.email,
+      photoURL: validatedData.photoURL || '',
+      zuid: validatedData.zuid,
+      type: validatedData.type
+    };
   }
 
   toJSON() {
-    return {
-      id: this._id,
-      name: this._name,
-      email: this._email,
-      photoURL: this._photoURL,
-      zuid: this._zuid,
-      type: this._type
+    return { ...this.data
     };
   }
 

package/es/domain/entities/Agent/index.js

@@ -1,2 +1,2 @@
 import Agent from './Agent';
-export { Agent }; //
+export { Agent };

package/es/domain/entities/Session/Session.js

@@ -0,0 +1,38 @@
+import { validateSchema } from '../../../core/utils';
+import { SessionSchema } from '../../schema';
+import { Actor } from '../Actor';
+export default class Session {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema(SessionSchema, data);
+    this.data = {
+      channelId: validatedData.channelId,
+      status: validatedData.status,
+      createdTime: validatedData.createdTime,
+      agentId: validatedData.agentId,
+      botId: validatedData.botId,
+      actor: new Actor(validatedData.actor),
+      subject: validatedData.subject,
+      messagesCount: validatedData.messagesCount,
+      agentLastActiveTime: validatedData.agentLastActiveTime,
+      contactLastActiveTime: validatedData.contactLastActiveTime,
+      lastActiveTime: validatedData.lastActiveTime,
+      unreadMessagesCount: validatedData.unreadMessagesCount,
+      integrationServiceId: validatedData.integrationServiceId,
+      replyStatus: validatedData.replyStatus,
+      id: validatedData.id,
+      contactId: validatedData.contactId,
+      meta: validatedData.meta,
+      assignee: validatedData.assignee ? new Actor(validatedData.assignee) : null,
+      channel: validatedData.channel
+    };
+  }
+
+  toJSON() {
+    return { ...this.data,
+      actor: this.data.actor.toJSON(),
+      assignee: this.data.assignee?.toJSON()
+    };
+  }
+
+}

package/es/domain/entities/Session/index.js

@@ -0,0 +1,2 @@
+import Session from './Session';
+export { Session };

package/es/domain/entities/index.js

@@ -1,2 +1,3 @@
 export * from './Actor';
-export * from './Agent';
+export * from './Agent';
+export * from './Session';

package/es/domain/enum/actor/index.js

@@ -0,0 +1,2 @@
+import ActorType from './ActorType';
+export { ActorType };

package/es/domain/enum/index.js

@@ -0,0 +1,3 @@
+export * from './integrationServices';
+export * from './session';
+export * from './actor';

package/es/domain/enum/integrationServices/IntegrationServices.js

@@ -0,0 +1,11 @@
+const IntegrationServices = {
+  TWILIO: 'TWILIO',
+  WHATSAPP: 'WHATSAPP',
+  TELEGRAM: 'TELEGRAM',
+  WECHAT: 'WECHAT',
+  LINE: 'LINE',
+  IM_TALK: 'IM_TALK',
+  FACEBOOKMESSENGER: 'FACEBOOKMESSENGER',
+  INSTAGRAM: 'INSTAGRAM'
+};
+export default IntegrationServices;

package/es/domain/enum/integrationServices/index.js

@@ -0,0 +1,2 @@
+import IntegrationServices from './IntegrationServices';
+export { IntegrationServices };

package/es/domain/enum/session/SessionReplyStatus.js

@@ -0,0 +1,20 @@
+const SessionReplyStatus = {
+  ACCEPTED: 'ACCEPTED',
+  CHANNEL_INACTIVE: 'CHANNEL_INACTIVE',
+  CHANNEL_REVOKED: 'CHANNEL_REVOKED',
+  SESSION_ENDED: 'SESSION_ENDED',
+  SESSION_BLOCKED: 'SESSION_BLOCKED',
+  SESSION_EXPIRED: 'SESSION_EXPIRED',
+  UNASSIGNED: 'UNASSIGNED',
+  NOT_AN_ASSIGNEE: 'NOT_AN_ASSIGNEE',
+  CREDIT_EXHAUSTED: 'CREDIT_EXHAUSTED',
+  ACCESSTOKEN_EXPIRED: 'ACCESSTOKEN_EXPIRED',
+  PERMISSION_REVOKED: 'PERMISSION_REVOKED',
+  UNEXPECTED_ERROR: 'UNEXPECTED_ERROR',
+  PAGE_REMOVED: 'PAGE_REMOVED',
+  SANDBOX_LIMIT_REACHED: 'SANDBOX_LIMIT_REACHED',
+  CHANNEL_DELETED: 'CHANNEL_DELETED',
+  ENDUSER_OFFLINE: 'ENDUSER_OFFLINE',
+  CONFIG_SKIPPED_CHANNEL: 'CONFIG_SKIPPED_CHANNEL'
+};
+export default SessionReplyStatus;

package/es/domain/enum/session/SessionStatus.js

@@ -0,0 +1,9 @@
+const SessionStatus = {
+  CREATED: 'CREATED',
+  OPEN: 'OPEN',
+  ON_PROGRESS: 'ON_PROGRESS',
+  ON_HOLD: 'ON_HOLD',
+  ENDED: 'ENDED',
+  BLOCKED: 'BLOCKED'
+};
+export default SessionStatus;

package/es/domain/enum/session/index.js

@@ -0,0 +1,3 @@
+import SessionReplyStatus from './SessionReplyStatus';
+import SessionStatus from './SessionStatus';
+export { SessionStatus, SessionReplyStatus };

package/es/domain/interfaces/BaseAPI.js

@@ -0,0 +1,58 @@
+export default class BaseAPI {
+  constructor(_ref) {
+    let {
+      httpClient
+    } = _ref;
+    this.httpClient = httpClient;
+  }
+
+  replacePathParams(url, params) {
+    let _url = url;
+    Object.entries(params).forEach(_ref2 => {
+      let [key, value] = _ref2;
+      _url = url.replace(`:${key}`, value);
+    });
+    return _url;
+  }
+
+  buildUrl(_ref3) {
+    let {
+      url,
+      params,
+      query
+    } = _ref3;
+
+    const _url = this.replacePathParams(url, params);
+
+    const queryString = this.buildQuery(query);
+
+    if (queryString) {
+      return `${_url}?${queryString}`;
+    }
+
+    return _url;
+  }
+
+  buildQuery(object) {
+    return new URLSearchParams(object).toString();
+  }
+
+  async request(_ref4) {
+    let {
+      urlConfig,
+      request
+    } = _ref4;
+    const url = this.buildUrl({
+      url: urlConfig.url,
+      params: request.params,
+      query: request.query
+    });
+    const httpRequest = await this.httpClient.request({
+      url,
+      method: urlConfig.method,
+      header: urlConfig.header
+    });
+    return httpRequest;
+  }
+
+}

package/es/domain/interfaces/channels/IChannelAgent.js

@@ -1,5 +1,18 @@
-export default class IChannelAgent {
-  static getChannelAgents() {
+import { GetChannelAgentsRequest } from '../../../infrastructure/interfaces/api';
+import BaseAPI from '../BaseAPI';
+export default class IChannelAgent extends BaseAPI {
+  constructor(_ref) {
+    let {
+      httpClient
+    } = _ref;
+    super({
+      httpClient
+    });
+  } // eslint-disable-next-line no-unused-vars
+
+
+  getChannelAgents() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GetChannelAgentsRequest;
     throw new Error('Method not implemented.');
   }
 

package/es/domain/interfaces/index.js

@@ -1 +1,2 @@
-export * from './channels';
+export * from './channels';
+export * from './sessions';

package/es/domain/interfaces/sessions/ISession.js

@@ -0,0 +1,19 @@
+import { UpdateSessionAssigneeRequest } from '../../../infrastructure/interfaces/api';
+import BaseAPI from '../BaseAPI';
+export default class ISession extends BaseAPI {
+  constructor(_ref) {
+    let {
+      httpClient
+    } = _ref;
+    super({
+      httpClient
+    });
+  } // eslint-disable-next-line no-unused-vars
+
+
+  updateAssignee() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UpdateSessionAssigneeRequest;
+    throw new Error('Method not implemented.');
+  }
+
+}

package/es/domain/interfaces/sessions/index.js

@@ -0,0 +1,2 @@
+import ISession from './ISession';
+export { ISession };

package/es/domain/schema/actor/ActorSchema.js

@@ -0,0 +1,33 @@
+import { ActorType } from '../../enum';
+const ActorSchema = {
+  name: {
+    type: 'string',
+    required: true
+  },
+  type: {
+    type: 'string',
+    required: true,
+    enum: Object.values(ActorType)
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  },
+  extId: {
+    type: 'string',
+    required: false
+  },
+  id: {
+    type: 'string',
+    required: true
+  },
+  email: {
+    type: 'string',
+    required: false
+  },
+  botType: {
+    type: 'string',
+    required: false
+  }
+};
+export default ActorSchema;

package/es/domain/schema/actor/AgentSchema.js

@@ -0,0 +1,29 @@
+import { ActorType } from '../../enum';
+const AgentSchema = {
+  id: {
+    type: 'string',
+    required: true
+  },
+  name: {
+    type: 'string',
+    required: true
+  },
+  email: {
+    type: 'string',
+    required: true
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  },
+  zuid: {
+    type: 'string',
+    required: true
+  },
+  type: {
+    type: 'string',
+    required: true,
+    enum: [ActorType.AGENT]
+  }
+};
+export default AgentSchema;

package/es/domain/schema/actor/index.js

@@ -0,0 +1,3 @@
+import ActorSchema from './ActorSchema';
+import AgentSchema from './AgentSchema';
+export { ActorSchema, AgentSchema };

package/es/domain/schema/index.js

@@ -0,0 +1,2 @@
+export * from './actor';
+export * from './session';

package/es/domain/schema/session/SessionSchema.js

@@ -0,0 +1,86 @@
+import { IntegrationServices, SessionReplyStatus, SessionStatus } from '../../enum';
+import { ActorSchema } from '../actor';
+const SessionSchema = {
+  channelId: {
+    type: 'string',
+    required: true
+  },
+  status: {
+    type: 'string',
+    required: true,
+    enum: Object.values(SessionStatus)
+  },
+  createdTime: {
+    type: 'string',
+    required: true
+  },
+  agentId: {
+    type: 'string',
+    required: false
+  },
+  botId: {
+    type: 'string',
+    required: false
+  },
+  actor: {
+    type: 'object',
+    required: true,
+    schema: ActorSchema
+  },
+  subject: {
+    type: 'string',
+    required: true
+  },
+  messagesCount: {
+    type: 'string',
+    required: true
+  },
+  agentLastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  contactLastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  lastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  unreadMessagesCount: {
+    type: 'string',
+    required: true
+  },
+  integrationServiceId: {
+    type: 'string',
+    required: true,
+    enum: Object.values(IntegrationServices)
+  },
+  replyStatus: {
+    type: 'string',
+    required: true,
+    enum: Object.values(SessionReplyStatus)
+  },
+  id: {
+    type: 'string',
+    required: true
+  },
+  contactId: {
+    type: 'string',
+    required: true
+  },
+  meta: {
+    type: 'array',
+    required: false
+  },
+  assignee: {
+    type: 'object',
+    required: false,
+    schema: ActorSchema
+  },
+  channel: {
+    type: 'string',
+    required: true
+  }
+};
+export default SessionSchema;

package/es/domain/schema/session/index.js

@@ -0,0 +1,2 @@
+import SessionSchema from './SessionSchema';
+export { SessionSchema };

package/es/domain/services/channels/ChannelAgentService.js

@@ -1,13 +1,26 @@
-import IChannelAgent from '../../interfaces/channels/IChannelAgent';
+import { CHANNEL_AGENTS_API_URLS } from '../../../config/urls/channels';
+import { ChannelAgentAdapter } from '../../../infrastructure/adapters';
+import { ChannelAgentAPI } from '../../../infrastructure/api';
+import { GetChannelAgentsRequest } from '../../../infrastructure/interfaces/api';
+import { IChannelAgent } from '../../interfaces';
 export default class ChannelAgentService extends IChannelAgent {
-  constructor(channelAPI, channelAgentAdapter) {
+  constructor(_ref) {
+    let {
+      channelAgentAPI,
+      channelAgentAdapter,
+      httpClient
+    } = _ref;
     super();
-    this.channelAPI = channelAPI;
-    this.channelAgentAdapter = channelAgentAdapter;
+    this.channelAgentAPI = channelAgentAPI || new ChannelAgentAPI({
+      httpClient,
+      urlConfig: CHANNEL_AGENTS_API_URLS
+    });
+    this.channelAgentAdapter = channelAgentAdapter || new ChannelAgentAdapter();
   }
 
   async getChannelAgents() {
-    const channelAgents = await this.channelAPI.getChannelAgents();
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GetChannelAgentsRequest;
+    const channelAgents = await this.channelAgentAPI.getChannelAgents(request);
     return channelAgents.map(this.channelAgentAdapter.adapt);
   }
 

package/es/domain/services/sessions/SessionService.js

@@ -0,0 +1,27 @@
+import SESSIONS_API_URLS from '../../../config/urls/sessions/sessions-api-url';
+import { SessionAdapter } from '../../../infrastructure/adapters';
+import { SessionAPI } from '../../../infrastructure/api/sessions';
+import { UpdateSessionAssigneeRequest } from '../../../infrastructure/interfaces/api';
+import { ISession } from '../../interfaces';
+export default class SessionService extends ISession {
+  constructor(_ref) {
+    let {
+      sessionAPI,
+      sessionAdapter,
+      httpClient
+    } = _ref;
+    super();
+    this.sessionAPI = sessionAPI || new SessionAPI({
+      httpClient,
+      urlConfig: SESSIONS_API_URLS
+    });
+    this.sessionAdapter = sessionAdapter || new SessionAdapter();
+  }
+
+  async updateAssignee() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UpdateSessionAssigneeRequest;
+    const session = await this.sessionAPI.updateAssignee(request);
+    return this.channelAgentAdapter.adapt(session);
+  }
+
+}

package/es/domain/services/sessions/index.js

@@ -0,0 +1,2 @@
+import SessionService from './SessionService';
+export { SessionService };

package/es/index.js

@@ -1 +1,8 @@
-export * from './domain';
+export * from './domain/entities';
+export * from './domain/enum';
+export * from './domain/interfaces';
+export * from './domain/services';
+export * from './infrastructure/sdk';
+export * from './infrastructure/adapters';
+export * from './infrastructure/api';
+export * from './infrastructure/interfaces/api';

package/es/infrastructure/adapters/BaseAdapter.js

@@ -0,0 +1,23 @@
+import { AdapterError } from '../../core/errors';
+/**
+ * Base adapter class that defines the contract for all adapters
+ * @abstract
+ */
+
+export default class BaseAdapter {
+  /**
+   * Adapts the input data to required format
+   * @param {*} data - Data to adapt
+   * @throws {AdapterError} When method is not implemented
+   */
+  adapt(data) {
+    if (this.constructor === BaseAdapter) {
+      throw new AdapterError(`${this.constructor.name}: adapt() must be implemented by subclass`);
+    }
+
+    if (!data) {
+      throw new AdapterError(`${this.constructor.name}: data parameter is required`);
+    }
+  }
+
+}

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

@@ -0,0 +1,35 @@
+import BaseAdapter from '../BaseAdapter';
+import { AdapterError } from '../../../core/errors';
+import { Agent } from '../../../domain/entities';
+/**
+ * Adapter for Channel Agent data
+ * @extends BaseAdapter
+ */
+
+export default class ChannelAgentAdapter extends BaseAdapter {
+  /**
+   * 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
+   */
+  static adapt(channelAgent) {
+    if (!channelAgent) {
+      throw new AdapterError('Channel agent data is required');
+    }
+
+    try {
+      return new Agent({
+        id: channelAgent.id,
+        name: channelAgent.name,
+        email: channelAgent.email,
+        photoURL: channelAgent.photoURL || '',
+        zuid: channelAgent.zuid,
+        type: channelAgent.type
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt channel agent: ${error.message}`);
+    }
+  }
+
+}

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

@@ -0,0 +1,2 @@
+import ChannelAgentAdapter from './ChannelAgentAdapter';
+export { ChannelAgentAdapter };

package/es/infrastructure/adapters/index.js

@@ -0,0 +1,2 @@
+export * from './channels';
+export * from './sessions';

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

@@ -0,0 +1,37 @@
+import BaseAdapter from '../BaseAdapter';
+import { AdapterError } from '../../../core/errors';
+import { Session } from '../../../domain/entities';
+export default class SessionAdapter extends BaseAdapter {
+  static 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,
+        channel: sessionData.channel
+      }).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 };

package/es/infrastructure/api/channels/ChannelAgentAPI.js

@@ -0,0 +1,26 @@
+import IChannelAgent from '../../../domain/interfaces/channels/IChannelAgent';
+import { GetChannelAgentsRequest } from '../../interfaces/api';
+export default class ChannelAgentAPI extends IChannelAgent {
+  constructor(_ref) {
+    let {
+      httpClient,
+      urlConfig
+    } = _ref;
+    super({
+      httpClient
+    });
+    this.httpClient = httpClient;
+    this.urlConfig = urlConfig;
+  }
+
+  async getChannelAgents() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GetChannelAgentsRequest;
+    const urlConfig = this.urlConfig.LIST;
+    const httpRequest = await this.request({
+      urlConfig,
+      request
+    });
+    return httpRequest;
+  }
+
+}

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

@@ -0,0 +1,2 @@
+import ChannelAgentAPI from './ChannelAgentAPI';
+export { ChannelAgentAPI };

package/es/infrastructure/api/index.js

@@ -0,0 +1 @@
+export * from './channels';

package/es/infrastructure/api/sessions/SessionAPI.js

@@ -0,0 +1,25 @@
+import { ISession } from '../../../domain/interfaces';
+import { UpdateSessionAssigneeRequest } from '../../interfaces/api';
+export default class SessionAPI extends ISession {
+  constructor(_ref) {
+    let {
+      httpClient,
+      urlConfig
+    } = _ref;
+    super({
+      httpClient
+    });
+    this.urlConfig = urlConfig;
+  }
+
+  async updateAssignee() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UpdateSessionAssigneeRequest;
+    const urlConfig = this.urlConfig.UPDATE_SESSION_ASSIGNEE;
+    const httpRequest = await this.request({
+      urlConfig,
+      request
+    });
+    return httpRequest;
+  }
+
+}

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

@@ -0,0 +1,2 @@
+import SessionAPI from './SessionAPI';
+export { SessionAPI };

package/es/infrastructure/interfaces/api/channels/agents/GetChannelAgentsRequest.js

@@ -0,0 +1,13 @@
+const params = {
+  channelId: null
+};
+const query = {
+  from: 0,
+  limit: 10,
+  searchStr: null
+};
+const GetChannelAgentsRequest = {
+  params,
+  query
+};
+export default GetChannelAgentsRequest;

package/es/infrastructure/interfaces/api/channels/agents/index.js

@@ -0,0 +1,2 @@
+import GetChannelAgentsRequest from './GetChannelAgentsRequest';
+export { GetChannelAgentsRequest };

package/es/infrastructure/interfaces/api/channels/index.js

@@ -0,0 +1 @@
+export * from './agents';

package/es/infrastructure/interfaces/api/index.js

@@ -0,0 +1,2 @@
+export * from './channels';
+export * from './sessions';

package/es/infrastructure/interfaces/api/sessions/UpdateSessionAssigneeRequest.js

@@ -0,0 +1,12 @@
+const params = {
+  sessionId: null
+};
+const query = {
+  agentId: null,
+  botId: null
+};
+const UpdateSessionAssigneeRequest = {
+  params,
+  query
+};
+export default UpdateSessionAssigneeRequest;

package/es/infrastructure/interfaces/api/sessions/index.js

@@ -0,0 +1,2 @@
+import UpdateSessionAssigneeRequest from './UpdateSessionAssigneeRequest';
+export { UpdateSessionAssigneeRequest };

package/es/infrastructure/interfaces/index.js

@@ -0,0 +1 @@
+export * from './api';

package/es/infrastructure/managers/ModuleFactory.js

@@ -0,0 +1,26 @@
+import { ModuleNames } from '../../core/constants';
+import { ChannelSDK } from '../sdk/channels';
+import { SessionSDK } from '../sdk/sessions';
+const ModuleFactory = {
+  [ModuleNames.CHANNELS]: _ref => {
+    let {
+      config,
+      httpClient
+    } = _ref;
+    return new ChannelSDK({
+      config,
+      httpClient
+    });
+  },
+  [ModuleNames.SESSIONS]: _ref2 => {
+    let {
+      config,
+      httpClient
+    } = _ref2;
+    return new SessionSDK({
+      config,
+      httpClient
+    });
+  }
+};
+export default ModuleFactory;

package/es/infrastructure/managers/ModuleManager.js

@@ -0,0 +1,46 @@
+import ModuleFactory from './ModuleFactory';
+export default class ModuleManager {
+  constructor() {
+    this._modules = new Map();
+  }
+
+  initialize(_ref) {
+    let {
+      config,
+      httpClient
+    } = _ref;
+    Object.entries(config).forEach(_ref2 => {
+      let [moduleName, moduleConfig] = _ref2;
+      this.initializeModule({
+        moduleName,
+        config: moduleConfig,
+        httpClient
+      });
+    });
+  }
+
+  initializeModule(_ref3) {
+    let {
+      moduleName,
+      config,
+      httpClient
+    } = _ref3;
+    const createModule = ModuleFactory[moduleName];
+
+    if (createModule) {
+      this._modules.set(moduleName, createModule({
+        config,
+        httpClient
+      }));
+    }
+  }
+
+  getModule(moduleName) {
+    return this._modules.get(moduleName);
+  }
+
+  hasModule(moduleName) {
+    return this._modules.has(moduleName);
+  }
+
+}

package/es/infrastructure/managers/index.js

@@ -0,0 +1,2 @@
+import ModuleManager from './ModuleManager';
+export { ModuleManager };

package/es/infrastructure/sdk/IMSDK.js

@@ -0,0 +1,29 @@
+import { ModuleNames } from '../../core/constants';
+import { ModuleManager } from '../managers';
+export default class IMSDK {
+  constructor(_ref) {
+    let {
+      config = {},
+      httpClient
+    } = _ref;
+    this._moduleManager = new ModuleManager();
+
+    this._moduleManager.initialize({
+      config,
+      httpClient
+    });
+  }
+
+  get channels() {
+    return this._moduleManager.getModule(ModuleNames.CHANNELS);
+  }
+
+  get sessions() {
+    return this._moduleManager.getModule(ModuleNames.SESSIONS);
+  }
+
+  hasModule(moduleName) {
+    return this._modules.has(moduleName);
+  }
+
+}

package/es/infrastructure/sdk/channels/ChannelAgentsSDK.js

@@ -0,0 +1,22 @@
+import { ChannelAgentService } from '../../../domain/services';
+import { GetChannelAgentsRequest } from '../../interfaces/api';
+export default class ChannelAgentsSDK {
+  constructor(_ref) {
+    let {
+      channelAgentAPI,
+      channelAgentAdapter,
+      httpClient
+    } = _ref;
+    this.channelAgentService = new ChannelAgentService({
+      channelAgentAPI,
+      channelAgentAdapter,
+      httpClient
+    });
+  }
+
+  async getAgents() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : GetChannelAgentsRequest;
+    return this.channelAgentService.getChannelAgents(request);
+  }
+
+}

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

@@ -0,0 +1,19 @@
+import ChannelAgentsSDK from './ChannelAgentsSDK';
+export default class ChannelSDK {
+  constructor(_ref) {
+    let {
+      config,
+      httpClient
+    } = _ref;
+    const {
+      channelAgentAPI,
+      channelAgentAdapter
+    } = config;
+    this.agents = new ChannelAgentsSDK({
+      channelAgentAPI,
+      channelAgentAdapter,
+      httpClient
+    });
+  }
+
+}

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

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

package/es/infrastructure/sdk/index.js

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

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

@@ -0,0 +1,22 @@
+import { SessionService } from '../../../domain/services/sessions';
+
+class SessionSDK extends SessionService {
+  constructor(_ref) {
+    let {
+      config,
+      httpClient
+    } = _ref;
+    const {
+      sessionAPI,
+      sessionAdapter
+    } = config;
+    super({
+      sessionAPI,
+      sessionAdapter,
+      httpClient
+    });
+  }
+
+}
+
+export default SessionSDK;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohoim/client-sdk",
-  "version": "1.0.0-poc1",
+  "version": "1.0.0-poc10",
   "description": "To have the client sdk for the IM",
   "main": "es/index.js",
   "module": "es/index.js",
@@ -10,12 +10,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "exports": {
-    ".": "./es/index.js",
-    "./interfaces": "./es/interfaces/index.js",
-    "./entities": "./es/entities/index.js",
-    "./services": "./es/services/index.js"
-  },
   "files": [
     "es",
     "!**/__tests__"

package/es/domain/index.js

@@ -1,3 +0,0 @@
-export * from './entities';
-export * from './interfaces';
-export * from './services';