@webitel/chat-web-sdk 0.0.2 → 0.0.4

package/dist/index.js

@@ -193,24 +193,6 @@ var require_deep_copy = __commonJS({
   }
 });
 
-// src/modules/messages/classes/Message.class.ts
-var Message = class {
-  _serviceConfig;
-  constructor(rawMessage, { serviceConfig }) {
-    Object.assign(this, rawMessage);
-    this._serviceConfig = serviceConfig;
-  }
-  get serviceConfig() {
-    return this._serviceConfig;
-  }
-  async markRead() {
-    throw new Error("Method not implemented.");
-  }
-};
-function createMessage(rawMessage, { serviceConfig }) {
-  return new Message(rawMessage, { serviceConfig });
-}
-
 // node_modules/@webitel/api-services/src/api/transformers/applyTransform.ts
 var applyTransform = (target, transformers, { debug = false, withContext = null } = {}) => {
   return transformers.reduce((result, transformer, index) => {
@@ -7073,14 +7055,11 @@ function preprocess(fn, schema) {
 // node_modules/zod/v4/classic/external.js
 config2(en_default2());
 
-// src/modules/messages/api/Messages.api.ts
-var getMessagesService = ({ axiosInstance }) => {
+// src/modules/account/api/Account.api.ts
+var getAccountService = ({ axiosInstance }) => {
   return {
-    getMessageHistory: async (threadId, params = {}) => {
-      const transformedParams = applyTransform(params, [
-        camelToSnake_transformer_default()
-      ]);
-      const response = await axiosInstance.get(`/v1/${threadId}/messages`, { params: transformedParams });
+    getAccount: async () => {
+      const response = await axiosInstance.get("/v1/auth/token");
       return applyTransform(response.data, [
         snakeToCamel_transformer_default()
       ]);
@@ -7088,56 +7067,141 @@ var getMessagesService = ({ axiosInstance }) => {
   };
 };
 
-// src/modules/messages/utils/fetchMessageHistory.ts
-var fetchRawMessageHistory = (config3) => async (threadId, params = {}) => {
-  const response = await getMessagesService(config3).getMessageHistory(threadId, params);
-  return response;
+// src/modules/account/utils/fetchAccount.ts
+var fetchAccount = async (config3) => {
+  return getAccountService(config3).getAccount();
 };
-var instantiateMessages = (rawMessages, { serviceConfig }) => {
-  return rawMessages.map((rawMessage) => createMessage(rawMessage, { serviceConfig }));
-};
-var fetchMessageHistory = async (config3, threadId, params = {}) => {
-  const rawResponse = await fetchRawMessageHistory(config3)(threadId, params);
+
+// src/modules/account/accountSevice.ts
+function useAccountService(config3) {
   return {
-    ...rawResponse,
-    messages: instantiateMessages(rawResponse.messages ?? [], { serviceConfig: config3 })
+    getAccount: () => fetchAccount(config3)
   };
+}
+var ServiceConfig = class {
+  baseUrl;
+  accessToken;
+  axiosInstance;
+  constructor({ baseUrl, accessToken }) {
+    this.baseUrl = baseUrl;
+    this.accessToken = accessToken;
+    this.axiosInstance = axios.create({
+      baseURL: this.baseUrl,
+      paramsSerializer: (params) => qs2.stringify(params, {
+        allowDots: true
+      })
+    });
+    this.setupAxiosTokenHandler();
+  }
+  setupAxiosTokenHandler() {
+    if (typeof this.accessToken === "function") {
+      this.axiosInstance.interceptors.request.use(async (config3) => {
+        config3.headers["X-Webitel-Access"] = await this.accessToken();
+        return config3;
+      });
+    } else {
+      this.axiosInstance.defaults.headers.common["X-Webitel-Access"] = this.accessToken;
+    }
+  }
 };
+function createServiceConfig(rawServiceConfig) {
+  return new ServiceConfig(rawServiceConfig);
+}
 
-// src/modules/messages/messagesSevice.ts
-function useMessagesService(config3) {
-  return {
-    fetchMessageHistory: (threadId, params) => fetchMessageHistory(config3, threadId, params ?? {})
-  };
+// src/modules/configs/socketConfig/SocketConfig.class.ts
+var SocketConfig = class {
+  baseUrl;
+  accessToken;
+  constructor({ baseUrl, accessToken }) {
+    this.baseUrl = baseUrl;
+    this.accessToken = accessToken;
+  }
+};
+function createSocketConfig(rawSocketConfig) {
+  return new SocketConfig(rawSocketConfig);
 }
 
-// src/modules/threads/classes/Thread.class.ts
-var Thread = class {
+// src/modules/messages/classes/Message.class.ts
+var Message = class {
   _serviceConfig;
-  id;
-  constructor(rawThread, { serviceConfig }) {
-    Object.assign(this, rawThread);
+  constructor(rawMessage, {
+    serviceConfig
+  }) {
+    Object.assign(this, rawMessage);
     this._serviceConfig = serviceConfig;
   }
-  async fetchMessageHistory(params) {
-    return useMessagesService(this.serviceConfig).fetchMessageHistory(this.id, params);
-  }
   get serviceConfig() {
     return this._serviceConfig;
   }
+  async markRead() {
+    throw new Error("Method not implemented.");
+  }
 };
-function createThread(rawThread, { serviceConfig }) {
-  return new Thread(rawThread, { serviceConfig });
+function createMessage(rawMessage, {
+  serviceConfig
+}) {
+  return new Message(rawMessage, {
+    serviceConfig
+  });
 }
 
-// src/modules/threads/api/Threads.api.ts
-var getThreadsService = ({ axiosInstance }) => {
+// src/modules/messages/api/Messages.api.ts
+var getMessagesService = ({ axiosInstance }) => {
   return {
-    getThreadsList: async (params = {}) => {
+    getMessageHistory: async (threadId, params = {}) => {
+      const transformedParams = applyTransform(params, [
+        camelToSnake_transformer_default()
+      ]);
+      const response = await axiosInstance.get(`/v1/${threadId}/messages`, {
+        params: transformedParams
+      });
+      return applyTransform(response.data, [
+        snakeToCamel_transformer_default()
+      ]);
+    },
+    sendTextMessage: async (params) => {
+      const transformedParams = applyTransform(params, [
+        camelToSnake_transformer_default()
+      ]);
+      const response = await axiosInstance.post(
+        "/v1/messages/text",
+        transformedParams
+      );
+      return applyTransform(response.data, [
+        snakeToCamel_transformer_default()
+      ]);
+    },
+    uploadFile: async (threadId, file2) => {
+      const formData = new FormData();
+      formData.append("file", file2);
+      const response = await axiosInstance.post(
+        `/api/storage/file/${threadId}/upload`,
+        formData
+      );
+      return applyTransform(response.data, [
+        snakeToCamel_transformer_default()
+      ]);
+    },
+    sendFileMessage: async (params) => {
       const transformedParams = applyTransform(params, [
         camelToSnake_transformer_default()
       ]);
-      const response = await axiosInstance.get("/v1/threads", { params: transformedParams });
+      const response = await axiosInstance.post(
+        "/v1/messages/file",
+        transformedParams
+      );
+      return applyTransform(response.data, [
+        snakeToCamel_transformer_default()
+      ]);
+    },
+    sendImageMessage: async (params) => {
+      const transformedParams = applyTransform(params, [
+        camelToSnake_transformer_default()
+      ]);
+      const response = await axiosInstance.post(
+        "/v1/messages/image",
+        transformedParams
+      );
       return applyTransform(response.data, [
         snakeToCamel_transformer_default()
       ]);
@@ -7145,31 +7209,138 @@ var getThreadsService = ({ axiosInstance }) => {
   };
 };
 
-// src/modules/threads/utils/fetchThreads.ts
-var fetchRawThreads = (config3) => async (params = {}) => {
-  const response = await getThreadsService(config3).getThreadsList(params);
+// src/modules/messages/utils/fetchMessageHistory.ts
+var fetchRawMessageHistory = (config3) => async (threadId, params = {}) => {
+  const response = await getMessagesService(config3).getMessageHistory(
+    threadId,
+    params
+  );
   return response;
 };
-var instantiateThreads = (rawThreads, { serviceConfig }) => {
-  return rawThreads.map((rawThread) => createThread(rawThread, { serviceConfig }));
+var instantiateMessages = (rawMessages, {
+  serviceConfig
+}) => {
+  return rawMessages.map(
+    (rawMessage) => createMessage(rawMessage, {
+      serviceConfig
+    })
+  );
 };
-var fetchThreads = async (config3, params = {}) => {
-  const rawThreadsResponse = await fetchRawThreads(config3)(params);
+var fetchMessageHistory = async (config3, threadId, params = {}) => {
+  const rawResponse = await fetchRawMessageHistory(config3)(threadId, params);
   return {
-    ...rawThreadsResponse,
-    threads: instantiateThreads(rawThreadsResponse.threads ?? [], {
+    ...rawResponse,
+    items: instantiateMessages(rawResponse.items ?? [], {
       serviceConfig: config3
     })
   };
 };
 
-// src/modules/threads/threadsSevice.ts
-function useThreadsService(config3) {
+// src/modules/messages/utils/sendFileMessage.ts
+var sendFileMessage = async (config3, params) => {
+  const { file: file2, threadId, document, ...restParams } = params;
+  const uploadResponse = await getMessagesService(config3).uploadFile(
+    threadId,
+    file2
+  );
+  const fileId = uploadResponse.id ?? uploadResponse.fileId;
+  if (!fileId) {
+    throw new Error("Storage upload did not return file id");
+  }
+  return getMessagesService(config3).sendFileMessage({
+    ...restParams,
+    document: {
+      ...document,
+      documents: [
+        {
+          fileName: file2.name,
+          id: fileId,
+          mimeType: file2.type,
+          sizeBytes: String(file2.size),
+          url: uploadResponse.fileUrl
+        }
+      ]
+    }
+  });
+};
+
+// src/modules/messages/utils/sendImageMessage.ts
+var sendImageMessage = async (config3, params) => {
+  const { file: file2, threadId, image, ...restParams } = params;
+  const uploadResponse = await getMessagesService(config3).uploadFile(
+    threadId,
+    file2
+  );
+  const imageId = uploadResponse.id ?? uploadResponse.fileId;
+  if (!imageId) {
+    throw new Error("Storage upload did not return file id");
+  }
+  return getMessagesService(config3).sendImageMessage({
+    ...restParams,
+    image: {
+      ...image,
+      images: [
+        {
+          id: imageId,
+          link: uploadResponse.fileUrl,
+          mimeType: file2.type,
+          name: file2.name
+        }
+      ]
+    }
+  });
+};
+
+// src/modules/messages/utils/sendTextMessage.ts
+var sendTextMessage = async (config3, params) => {
+  return getMessagesService(config3).sendTextMessage(params);
+};
+
+// src/modules/messages/messagesSevice.ts
+function useMessagesService(config3) {
   return {
-    fetchThreads: (params) => fetchThreads(config3, params ?? {})
+    fetchMessageHistory: (threadId, params) => fetchMessageHistory(config3, threadId, params ?? {}),
+    sendTextMessage: (params) => sendTextMessage(config3, params),
+    sendFileMessage: (params) => sendFileMessage(config3, params),
+    sendImageMessage: (params) => sendImageMessage(config3, params)
   };
 }
 
+// src/modules/contacts/classes/Contact.class.ts
+var Contact = class {
+  _serviceConfig;
+  sub;
+  iss;
+  constructor(rawContact, {
+    serviceConfig
+  }) {
+    Object.assign(this, rawContact);
+    this._serviceConfig = serviceConfig;
+  }
+  async sendTextMessage(body, params = {}) {
+    return useMessagesService(this.serviceConfig).sendTextMessage({
+      ...params,
+      body,
+      to: {
+        contact: {
+          sub: this.sub,
+          iss: this.iss
+        }
+      }
+    });
+  }
+  get serviceConfig() {
+    return this._serviceConfig;
+  }
+};
+function createContact(rawContact, {
+  serviceConfig
+}) {
+  return new Contact(rawContact, {
+    serviceConfig
+  });
+}
+
 // src/modules/contacts/api/Contacts.api.ts
 var getContactsService = ({ axiosInstance }) => {
   return {
@@ -7177,7 +7348,9 @@ var getContactsService = ({ axiosInstance }) => {
       const transformedParams = applyTransform(params, [
         camelToSnake_transformer_default()
       ]);
-      const response = await axiosInstance.get("/v1/contacts", { params: transformedParams });
+      const response = await axiosInstance.get("/v1/contacts", {
+        params: transformedParams
+      });
       return applyTransform(response.data, [
         snakeToCamel_transformer_default()
       ]);
@@ -7185,31 +7358,19 @@ var getContactsService = ({ axiosInstance }) => {
   };
 };
 
-// src/modules/contacts/classes/Contact.class.ts
-var Contact = class {
-  _serviceConfig;
-  constructor(rawContact, { serviceConfig }) {
-    Object.assign(this, rawContact);
-    this._serviceConfig = serviceConfig;
-  }
-  async sendMessage() {
-    throw new Error("Method not implemented.");
-  }
-  get serviceConfig() {
-    return this._serviceConfig;
-  }
-};
-function createContact(rawContact, { serviceConfig }) {
-  return new Contact(rawContact, { serviceConfig });
-}
-
 // src/modules/contacts/utils/fetchContacts.ts
 var fetchRawContacts = (config3) => async (params = {}) => {
   const response = await getContactsService(config3).getContactsList(params);
   return response;
 };
-var instantiateContacts = (rawContacts, { serviceConfig }) => {
-  return rawContacts.map((rawContact) => createContact(rawContact, { serviceConfig }));
+var instantiateContacts = (rawContacts, {
+  serviceConfig
+}) => {
+  return rawContacts.map(
+    (rawContact) => createContact(rawContact, {
+      serviceConfig
+    })
+  );
 };
 var fetchContacts = async (config3, params = {}) => {
   const rawResponse = await fetchRawContacts(config3)(params);
@@ -7227,52 +7388,6 @@ function useContactsService(config3) {
     fetchContacts: (params) => fetchContacts(config3, params ?? {})
   };
 }
-var ServiceConfig = class {
-  baseUrl;
-  accessToken;
-  axiosInstance;
-  constructor({
-    baseUrl,
-    accessToken
-  }) {
-    this.baseUrl = baseUrl;
-    this.accessToken = accessToken;
-    this.axiosInstance = axios.create({
-      baseURL: this.baseUrl,
-      paramsSerializer: (params) => qs2.stringify(params, { allowDots: true })
-    });
-    this.setupAxiosTokenHandler();
-  }
-  setupAxiosTokenHandler() {
-    if (typeof this.accessToken === "function") {
-      this.axiosInstance.interceptors.request.use(async (config3) => {
-        config3.headers["X-Webitel-Access"] = await this.accessToken();
-        return config3;
-      });
-    } else {
-      this.axiosInstance.defaults.headers.common["X-Webitel-Access"] = this.accessToken;
-    }
-  }
-};
-function createServiceConfig(rawServiceConfig) {
-  return new ServiceConfig(rawServiceConfig);
-}
-
-// src/modules/configs/socketConfig/SocketConfig.class.ts
-var SocketConfig = class {
-  baseUrl;
-  accessToken;
-  constructor({
-    baseUrl,
-    accessToken
-  }) {
-    this.baseUrl = baseUrl;
-    this.accessToken = accessToken;
-  }
-};
-function createSocketConfig(rawSocketConfig) {
-  return new SocketConfig(rawSocketConfig);
-}
 
 // src/modules/socket/enums/ChatsSocketMessage.enum.ts
 var ChatsSocketMessage = {
@@ -7294,11 +7409,11 @@ var SocketClientConnectionStatus = {
 
 // src/modules/socket/utils/getSocketMessageNameFromEvent.ts
 var wireToGetter = {
-  [ChatsSocketMessage.Connected]: (e) => e.connected,
-  [ChatsSocketMessage.Disconnected]: (e) => e.disconnected,
-  [ChatsSocketMessage.Error]: (e) => e.error,
-  [ChatsSocketMessage.ThreadMessage]: (e) => e.message,
-  [ChatsSocketMessage.ThreadCreated]: (e) => e.threadCreated
+  // [ChatsSocketMessage.Connected]: (e) => e.connected,
+  // [ChatsSocketMessage.Disconnected]: (e) => e.disconnected,
+  // [ChatsSocketMessage.Error]: (e) => e.error,
+  // [ChatsSocketMessage.ThreadMessage]: (e) => e.message,
+  // [ChatsSocketMessage.ThreadCreated]: (e) => e.threadCreated,
 };
 function getSocketMessageNameFromEvent(sourceEvent) {
   for (const value of Object.values(ChatsSocketMessage)) {
@@ -7365,6 +7480,111 @@ function createChatsSocketClient(config3) {
   return new ChatsSocketClient(config3);
 }
 
-export { ChatsSocketMessage, createChatsSocketClient, createServiceConfig, createSocketConfig, useContactsService, useMessagesService, useThreadsService };
+// src/modules/threads/classes/Thread.class.ts
+var Thread = class {
+  _serviceConfig;
+  id;
+  constructor(rawThread, {
+    serviceConfig
+  }) {
+    Object.assign(this, rawThread);
+    this._serviceConfig = serviceConfig;
+  }
+  async fetchMessageHistory(params) {
+    return useMessagesService(this.serviceConfig).fetchMessageHistory(
+      this.id,
+      params
+    );
+  }
+  async sendTextMessage(body, params = {}) {
+    return useMessagesService(this.serviceConfig).sendTextMessage({
+      ...params,
+      body,
+      to: {
+        threadId: this.id
+      }
+    });
+  }
+  async sendFileMessage(file2, params = {}) {
+    return useMessagesService(this.serviceConfig).sendFileMessage({
+      ...params,
+      file: file2,
+      threadId: this.id,
+      to: {
+        threadId: this.id
+      }
+    });
+  }
+  async sendImageMessage(file2, params = {}) {
+    return useMessagesService(this.serviceConfig).sendImageMessage({
+      ...params,
+      file: file2,
+      threadId: this.id,
+      to: {
+        threadId: this.id
+      }
+    });
+  }
+  get serviceConfig() {
+    return this._serviceConfig;
+  }
+};
+function createThread(rawThread, {
+  serviceConfig
+}) {
+  return new Thread(rawThread, {
+    serviceConfig
+  });
+}
+
+// src/modules/threads/api/Threads.api.ts
+var getThreadsService = ({ axiosInstance }) => {
+  return {
+    getThreadsList: async (params = {}) => {
+      const transformedParams = applyTransform(params, [
+        camelToSnake_transformer_default()
+      ]);
+      const response = await axiosInstance.get("/v1/threads", {
+        params: transformedParams
+      });
+      return applyTransform(response.data, [
+        snakeToCamel_transformer_default()
+      ]);
+    }
+  };
+};
+
+// src/modules/threads/utils/fetchThreads.ts
+var fetchRawThreads = (config3) => async (params = {}) => {
+  const response = await getThreadsService(config3).getThreadsList(params);
+  return response;
+};
+var instantiateThreads = (rawThreads, {
+  serviceConfig
+}) => {
+  return rawThreads.map(
+    (rawThread) => createThread(rawThread, {
+      serviceConfig
+    })
+  );
+};
+var fetchThreads = async (config3, params = {}) => {
+  const rawThreadsResponse = await fetchRawThreads(config3)(params);
+  return {
+    ...rawThreadsResponse,
+    items: instantiateThreads(rawThreadsResponse.items ?? [], {
+      serviceConfig: config3
+    })
+  };
+};
+
+// src/modules/threads/threadsSevice.ts
+function useThreadsService(config3) {
+  return {
+    fetchThreads: (params) => fetchThreads(config3, params ?? {})
+  };
+}
+
+export { ChatsSocketMessage, createChatsSocketClient, createServiceConfig, createSocketConfig, useAccountService, useContactsService, useMessagesService, useThreadsService };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map