@secrecy/lib 1.0.0-dev.54 → 1.0.0-dev.55

package/dist/client/SecrecyMailClient.js

@@ -0,0 +1,1189 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/* eslint-disable @typescript-eslint/naming-convention */
+import { generate } from "shortid";
+import { filesCache, usersCache } from "../cache.js";
+import { encryptCryptoBox, sodium } from "../index.js";
+import { convertInternalMailToExternal } from "./convert/mail.js";
+import { mailSelector } from "./types/selectors.js";
+
+var _client = /*#__PURE__*/_classPrivateFieldLooseKey("client");
+
+var _keys = /*#__PURE__*/_classPrivateFieldLooseKey("keys");
+
+var _thunder = /*#__PURE__*/_classPrivateFieldLooseKey("thunder");
+
+export class SecrecyMailClient {
+  constructor(client, keys, thunder) {
+    Object.defineProperty(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _keys, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _thunder, {
+      writable: true,
+      value: void 0
+    });
+
+    this._eachUser = async (files, subject, body, idOrMail) => {
+      let u = usersCache.get(idOrMail);
+
+      if (!u || !("publicKey" in u)) {
+        try {
+          const req = await _classPrivateFieldLooseBase(this, _client)[_client].user({
+            userId: idOrMail,
+            withPublicKey: true
+          });
+
+          if (!req) {
+            return null;
+          }
+
+          if (req.__typename !== "SuccessResponse") {
+            return null;
+          }
+
+          u = req.data;
+        } catch {
+          return null;
+        }
+
+        if (!u) {
+          return null;
+        }
+      }
+
+      if (!("publicKey" in u)) {
+        throw new Error("User " + idOrMail + " have no public key");
+      }
+
+      const recipientsFiles = new Array();
+
+      for (const f of files) {
+        let fileInHistory = filesCache.get(f.id);
+
+        if (!fileInHistory) {
+          await _classPrivateFieldLooseBase(this, _client)[_client].cloud.file({
+            id: f.id
+          });
+          fileInHistory = filesCache.get(f.id);
+
+          if (!fileInHistory) {
+            throw new Error("File " + f.name + " (" + f.id + ") does not exists");
+          }
+        }
+
+        const key = fileInHistory.key;
+        recipientsFiles.push({
+          id: f.id,
+          name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), u.publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+          fileKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), u.publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey))
+        });
+      }
+
+      return {
+        recipientId: u.id,
+        body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), u.publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+        subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), u.publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+        files: recipientsFiles
+      };
+    };
+
+    _classPrivateFieldLooseBase(this, _client)[_client] = client;
+    _classPrivateFieldLooseBase(this, _keys)[_keys] = keys;
+    _classPrivateFieldLooseBase(this, _thunder)[_thunder] = thunder;
+  }
+
+  async get(_ref) {
+    let {
+      id
+    } = _ref;
+    const {
+      mail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      mail: [{
+        id
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on QueryMailResponse": {
+          __typename: true,
+          mail: mailSelector
+        }
+      }]
+    });
+
+    if (!mail) {
+      return null;
+    }
+
+    if (mail.__typename === "ErrorAccessDenied") {
+      return mail;
+    }
+
+    if (!mail.mail) {
+      return null;
+    }
+
+    const result = convertInternalMailToExternal(mail.mail, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+
+    if (!result) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: result
+    };
+  }
+
+  async recover(_ref2) {
+    let {
+      mailId
+    } = _ref2;
+    const {
+      recoverMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      recoverMail: [{
+        mailId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on RecoverMailResponse": {
+          __typename: true,
+          recoverMail: true
+        }
+      }]
+    });
+
+    if (!recoverMail) {
+      return null;
+    }
+
+    if (recoverMail.__typename === "ErrorAccessDenied") {
+      return recoverMail;
+    }
+
+    if (recoverMail.__typename === "ErrorBasic") {
+      return recoverMail;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: recoverMail.recoverMail
+    };
+  }
+
+  async deletedMails(_ref3) {
+    let {
+      mailType
+    } = _ref3;
+    const {
+      deletedMails
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      deletedMails: [{
+        mailType
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DeletedMailsResponse": {
+          __typename: true,
+          deletedMails: mailSelector
+        }
+      }]
+    });
+
+    if (!deletedMails) {
+      return null;
+    }
+
+    if (deletedMails.__typename === "ErrorAccessDenied") {
+      return deletedMails;
+    }
+
+    const mails = new Array();
+
+    for (const m of deletedMails.deletedMails) {
+      const mail = convertInternalMailToExternal(m, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+
+      if (mail) {
+        mails.push(mail);
+      }
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: mails
+    };
+  }
+
+  async create(data, customMessage) {
+    const mail = await this.createDraft(data);
+
+    if (!mail) {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    if (mail.__typename === "ErrorBasic") {
+      return mail;
+    }
+
+    if (mail.__typename === "ErrorAccessDenied") {
+      return mail;
+    }
+
+    const result = await this.sendDraft(mail.data.mailIntegrityId, customMessage);
+
+    if (!result) {
+      return null;
+    }
+
+    if (result.__typename === "ErrorAccessDenied") {
+      return result;
+    }
+
+    if (result.__typename === "ErrorBasic") {
+      return result;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: result.data
+    };
+  }
+
+  async waitingReceivedMails() {
+    const {
+      user
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query")({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            waitingReceivedMails: {
+              date: true,
+              attachmentsCount: true,
+              sender: {
+                id: true,
+                firstname: true,
+                lastname: true,
+                email: true,
+                publicKey: true
+              },
+              recipients: {
+                id: true,
+                firstname: true,
+                lastname: true,
+                email: true,
+                publicKey: true
+              },
+              temporaryRecipients: {
+                email: true
+              }
+            }
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (!user.user) {
+      return null;
+    }
+
+    const result = user.user.waitingReceivedMails.map(m => _objectSpread(_objectSpread({
+      id: generate()
+    }, m), {}, {
+      date: new Date(m.date)
+    }));
+    return {
+      __typename: "SuccessResponse",
+      data: result
+    };
+  }
+
+  async updateDraft(draftId, _ref4) {
+    let {
+      body,
+      subject,
+      files,
+      recipientsIds,
+      replyTo
+    } = _ref4;
+    const drafts = await this.draftMails();
+
+    if (!drafts) {
+      return null;
+    }
+
+    if (drafts.__typename !== "SuccessResponse") {
+      return drafts;
+    }
+
+    const draft = drafts.data.find(d => d.mailIntegrityId === draftId);
+
+    if (!draft) {
+      throw new Error("Invalid draft " + draftId);
+    }
+
+    let hashKey = null;
+    let hash = null;
+
+    if (body || subject) {
+      hashKey = sodium.randombytes_buf(sodium.crypto_generichash_KEYBYTES, "hex");
+      hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({
+        body,
+        subject
+      }), hashKey, "hex");
+    }
+
+    const senderFiles = new Array();
+
+    if (files) {
+      for (const f of files) {
+        let file = filesCache.get(f.id);
+
+        if (!file) {
+          await _classPrivateFieldLooseBase(this, _client)[_client].cloud.file({
+            id: f.id
+          });
+          file = filesCache.get(f.id);
+
+          if (!file) {
+            throw new Error("File " + f.name + " (" + f.id + ") does not exists");
+          }
+        }
+
+        senderFiles.push({
+          id: file.id,
+          fileKey: sodium.to_hex(encryptCryptoBox(sodium.from_string(file.key), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+          name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey))
+        });
+      }
+    }
+
+    const {
+      updateDraftMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      updateDraftMail: [{
+        draftId,
+        recipients: recipientsIds,
+        replyTo,
+        body: body ? sodium.to_hex(encryptCryptoBox(sodium.from_string(body), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)) : null,
+        subject: subject ? sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)) : null,
+        senderFiles,
+        hash,
+        hashKey
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on UpdateDraftMailResponse": {
+          __typename: true,
+          updateDraftMail: mailSelector
+        }
+      }]
+    });
+
+    if (!updateDraftMail) {
+      return null;
+    }
+
+    if (updateDraftMail.__typename === "ErrorAccessDenied") {
+      return updateDraftMail;
+    }
+
+    if (updateDraftMail.__typename === "ErrorBasic") {
+      return updateDraftMail;
+    }
+
+    if (!updateDraftMail.updateDraftMail) {
+      return null;
+    }
+
+    const result = convertInternalMailToExternal(updateDraftMail.updateDraftMail, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+    return {
+      __typename: "SuccessResponse",
+      data: result
+    };
+  }
+
+  async deleteDraft(draftId) {
+    var _deleteDraftMail$dele;
+
+    const {
+      deleteDraftMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      deleteDraftMail: [{
+        draftId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DeleteDraftMailResponse": {
+          __typename: true,
+          deleteDraftMail: true
+        }
+      }]
+    });
+
+    if (!deleteDraftMail) {
+      return null;
+    }
+
+    if (deleteDraftMail.__typename === "ErrorAccessDenied") {
+      return deleteDraftMail;
+    }
+
+    if (!deleteDraftMail.deleteDraftMail) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: (_deleteDraftMail$dele = deleteDraftMail.deleteDraftMail) != null ? _deleteDraftMail$dele : false
+    };
+  }
+
+  async deleteTrash(_ref5) {
+    let {
+      ids
+    } = _ref5;
+    const {
+      deleteMailTrash
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      deleteMailTrash: [{
+        ids
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DeleteMailTrashResponse": {
+          __typename: true,
+          deleteMailTrash: true
+        }
+      }]
+    });
+
+    if (!deleteMailTrash) {
+      return null;
+    }
+
+    if (deleteMailTrash.__typename === "ErrorAccessDenied") {
+      return deleteMailTrash;
+    }
+
+    if (!deleteMailTrash.deleteMailTrash) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: deleteMailTrash.deleteMailTrash
+    };
+  }
+
+  async emptyTrash() {
+    const {
+      emptyMailTrash
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      emptyMailTrash: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on EmptyMailTrashResponse": {
+          __typename: true,
+          emptyMailTrash: true
+        }
+      }
+    });
+
+    if (!emptyMailTrash) {
+      return null;
+    }
+
+    if (emptyMailTrash.__typename === "ErrorAccessDenied") {
+      return emptyMailTrash;
+    }
+
+    if (!emptyMailTrash.emptyMailTrash) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: emptyMailTrash.emptyMailTrash
+    };
+  }
+
+  async delete(_ref6) {
+    let {
+      mailId
+    } = _ref6;
+    const {
+      deleteMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      deleteMail: [{
+        mailId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DeleteMailResponse": {
+          __typename: true,
+          deleteMail: true
+        }
+      }]
+    });
+
+    if (!deleteMail) {
+      return null;
+    }
+
+    if (deleteMail.__typename === "ErrorAccessDenied") {
+      return deleteMail;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: deleteMail.deleteMail
+    };
+  }
+
+  async sendDraft(draftId, customMessage) {
+    const drafts = await this.draftMails();
+
+    if (!drafts) {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    if (drafts.__typename !== "SuccessResponse") {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    const draft = drafts.data.find(d => d.mailIntegrityId === draftId);
+
+    if (!draft) {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    const recipients = new Array();
+    const temporaryRecipients = new Array();
+
+    for (const {
+      email
+    } of draft.temporaryRecipients) {
+      if (!email) {
+        continue;
+      }
+
+      const input = await this._eachUser(draft.files, draft.subject, draft.body, email);
+
+      if (!input) {
+        temporaryRecipients.push(email);
+      } else {
+        recipients.push(input);
+      }
+    }
+
+    for (const {
+      id
+    } of draft.recipients) {
+      const input = await this._eachUser(draft.files, draft.subject, draft.body, id);
+
+      if (!input) {
+        temporaryRecipients.push(id);
+      } else {
+        recipients.push(input);
+      }
+    }
+
+    const {
+      sendDraftMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      sendDraftMail: [{
+        temporaryRecipients,
+        recipients,
+        draftMailId: draft.mailIntegrityId,
+        customMessage
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on SendDraftMailResponse": {
+          __typename: true,
+          sendDraftMail: true
+        }
+      }]
+    });
+
+    if (!sendDraftMail) {
+      return null;
+    }
+
+    if (sendDraftMail.__typename === "ErrorAccessDenied") {
+      return sendDraftMail;
+    }
+
+    if (sendDraftMail.__typename === "ErrorBasic") {
+      return sendDraftMail;
+    }
+
+    if (!sendDraftMail.sendDraftMail) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: sendDraftMail.sendDraftMail
+    };
+  }
+
+  async sendWaitingEmails() {
+    // TODO opti this
+    const mails = await this.sentMails();
+
+    if (!mails) {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    if (mails.__typename !== "SuccessResponse") {
+      return {
+        __typename: "SuccessResponse",
+        data: false
+      };
+    }
+
+    const filtered = mails.data.filter(m => m.temporaryRecipients.length > 0);
+
+    for (const mail of filtered) {
+      for (const {
+        email
+      } of mail.temporaryRecipients) {
+        if (!email) {
+          continue;
+        }
+
+        try {
+          const input = await this._eachUser(mail.files, mail.subject, mail.body, email);
+
+          if (!input) {
+            continue;
+          }
+
+          await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+            sendOneMail: [{
+              mailIntegrityId: mail.mailIntegrityId,
+              recipient: input
+            }, {
+              "...on ErrorAccessDenied": {
+                __typename: true,
+                message: true
+              },
+              "...on ErrorBasic": {
+                __typename: true,
+                message: true
+              },
+              "...on RecoverNodeResponse": {
+                __typename: true,
+                recoverNode: true
+              }
+            }]
+          });
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: false
+    };
+  }
+
+  async createDraft(_ref7) {
+    let {
+      body,
+      subject,
+      files,
+      recipientsIds,
+      replyTo
+    } = _ref7;
+    const hashKey = sodium.randombytes_buf(sodium.crypto_generichash_KEYBYTES, "hex");
+    const hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({
+      body,
+      subject
+    }), hashKey, "hex");
+    const senderFiles = new Array();
+
+    for (const f of files) {
+      let file = filesCache.get(f.id);
+
+      if (!file) {
+        await _classPrivateFieldLooseBase(this, _client)[_client].cloud.file({
+          id: f.id
+        });
+        file = filesCache.get(f.id);
+
+        if (!file) {
+          throw new Error("File " + f.name + " (" + f.id + ") does not exists");
+        }
+      }
+
+      senderFiles.push({
+        id: file.id,
+        fileKey: sodium.to_hex(encryptCryptoBox(sodium.from_string(file.key), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+        name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey))
+      });
+    }
+
+    const {
+      createDraftMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      createDraftMail: [{
+        recipients: recipientsIds,
+        replyTo,
+        body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+        subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), _classPrivateFieldLooseBase(this, _keys)[_keys].publicKey, _classPrivateFieldLooseBase(this, _keys)[_keys].privateKey)),
+        senderFiles,
+        hash,
+        hashKey
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on CreateDraftMailResponse": {
+          __typename: true,
+          createDraftMail: mailSelector
+        }
+      }]
+    });
+
+    if (!createDraftMail) {
+      return null;
+    }
+
+    if (createDraftMail.__typename === "ErrorAccessDenied") {
+      return createDraftMail;
+    }
+
+    if (createDraftMail.__typename === "ErrorBasic") {
+      return createDraftMail;
+    }
+
+    if (!createDraftMail.createDraftMail) {
+      return null;
+    }
+
+    const result = convertInternalMailToExternal(createDraftMail.createDraftMail, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+    return {
+      __typename: "SuccessResponse",
+      data: result
+    };
+  }
+
+  async read(_ref8) {
+    let {
+      mailId
+    } = _ref8;
+    const {
+      readMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      readMail: [{
+        mailId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on ReadMailResponse": {
+          __typename: true,
+          readMail: true
+        }
+      }]
+    });
+
+    if (!readMail) {
+      return null;
+    }
+
+    if (readMail.__typename === "ErrorAccessDenied") {
+      return readMail;
+    }
+
+    if (readMail.__typename === "ErrorBasic") {
+      return readMail;
+    }
+
+    if (readMail.__typename === "ErrorNotFound") {
+      return readMail;
+    }
+
+    if (!readMail.readMail) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: readMail.readMail
+    };
+  }
+
+  async unread(_ref9) {
+    let {
+      mailId
+    } = _ref9;
+    const {
+      unreadMail
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      unreadMail: [{
+        mailId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UnreadMailResponse": {
+          __typename: true,
+          unreadMail: true
+        }
+      }]
+    });
+
+    if (!unreadMail) {
+      return null;
+    }
+
+    if (unreadMail.__typename === "ErrorAccessDenied") {
+      return unreadMail;
+    }
+
+    if (unreadMail.__typename === "ErrorBasic") {
+      return unreadMail;
+    }
+
+    if (unreadMail.__typename === "ErrorNotFound") {
+      return unreadMail;
+    }
+
+    if (!unreadMail.unreadMail) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: unreadMail.unreadMail
+    };
+  }
+
+  async receivedMails() {
+    const {
+      user
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            receivedMails: mailSelector
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (!user.user) {
+      return null;
+    } // TODO get actual mails on this app only
+
+
+    const receivedMails = new Array();
+
+    for (const m of user.user.receivedMails) {
+      const mail = convertInternalMailToExternal(m, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+
+      if (mail) {
+        receivedMails.push(mail);
+      }
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: receivedMails
+    };
+  }
+
+  async sentMails() {
+    const {
+      user
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            sentMails: mailSelector
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (!user.user) {
+      return null;
+    } // TODO get actual mails on this app only
+
+
+    const sentMails = new Array();
+
+    for (const m of user.user.sentMails) {
+      const mail = convertInternalMailToExternal(m, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+
+      if (mail) {
+        sentMails.push(mail);
+      }
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: sentMails
+    };
+  }
+
+  async draftMails() {
+    const {
+      user
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            draftMails: mailSelector
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (!user.user) {
+      return null;
+    } // TODO get actual mails on this app only
+
+
+    const draftMails = new Array();
+
+    for (const m of user.user.draftMails) {
+      const draft = convertInternalMailToExternal(m, _classPrivateFieldLooseBase(this, _keys)[_keys]);
+
+      if (draft) {
+        draftMails.push(draft);
+      }
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: draftMails
+    };
+  }
+
+  async unreadReceivedMailsCount() {
+    const {
+      unreadReceivedMailsCount
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query")({
+      unreadReceivedMailsCount: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on UnreadReceivedMailsCountResponse": {
+          __typename: true,
+          count: true
+        }
+      }
+    });
+
+    if (!unreadReceivedMailsCount) {
+      return null;
+    }
+
+    if (unreadReceivedMailsCount.__typename === "ErrorAccessDenied") {
+      return unreadReceivedMailsCount;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: unreadReceivedMailsCount.count
+    };
+  }
+
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["generate","filesCache","usersCache","encryptCryptoBox","sodium","convertInternalMailToExternal","mailSelector","SecrecyMailClient","constructor","client","keys","thunder","_eachUser","files","subject","body","idOrMail","u","get","req","user","userId","withPublicKey","__typename","data","Error","recipientsFiles","Array","f","fileInHistory","id","cloud","file","name","key","push","to_hex","from_string","publicKey","privateKey","fileKey","from_hex","recipientId","mail","scalars","DateTime","decode","e","Date","encode","toISOString","message","result","recover","mailId","recoverMail","deletedMails","mailType","mails","m","create","customMessage","createDraft","sendDraft","mailIntegrityId","waitingReceivedMails","date","attachmentsCount","sender","firstname","lastname","email","recipients","temporaryRecipients","map","updateDraft","draftId","recipientsIds","replyTo","drafts","draftMails","draft","find","d","hashKey","hash","randombytes_buf","crypto_generichash_KEYBYTES","crypto_generichash","crypto_generichash_BYTES","JSON","stringify","senderFiles","updateDraftMail","Json","parse","BigInt","toString","deleteDraft","deleteDraftMail","deleteTrash","ids","deleteMailTrash","emptyTrash","emptyMailTrash","delete","deleteMail","input","sendDraftMail","draftMailId","sendWaitingEmails","sentMails","filtered","filter","length","sendOneMail","recipient","recoverNode","createDraftMail","read","readMail","unread","unreadMail","receivedMails","unreadReceivedMailsCount","count"],"sources":["../../src/client/SecrecyMailClient.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nimport { generate } from \"shortid\";\nimport { filesCache, usersCache } from \"../cache.js\";\nimport type { ErrorAccessDenied, ErrorBasic, ErrorNotFound } from \"../error.js\";\nimport type {\n  SuccessResponse,\n  KeyPair,\n  NewMail,\n  SecrecyClient\n} from \"../index.js\";\nimport { encryptCryptoBox, sodium } from \"../index.js\";\nimport type { MailType, Thunder } from \"../zeus/index.js\";\nimport { convertInternalMailToExternal } from \"./convert/mail.js\";\nimport type {\n  DraftMail,\n  Mail,\n  MailFileInput,\n  MailRecipientInput,\n  ReceivedMail,\n  SentMail,\n  WaitingReceivedMail\n} from \"./types/index.js\";\nimport { mailSelector } from \"./types/selectors.js\";\n\nexport class SecrecyMailClient {\n  #client: SecrecyClient;\n\n  #keys: KeyPair;\n\n  #thunder: ReturnType<typeof Thunder>;\n\n  constructor(\n    client: SecrecyClient,\n    keys: KeyPair,\n    thunder: ReturnType<typeof Thunder>\n  ) {\n    this.#client = client;\n    this.#keys = keys;\n    this.#thunder = thunder;\n  }\n\n  async get({\n    id\n  }: {\n    id: string;\n  }): Promise<SuccessResponse<Mail> | ErrorAccessDenied | null> {\n    const { mail } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      mail: [\n        {\n          id\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on QueryMailResponse\": {\n            __typename: true,\n            mail: mailSelector\n          }\n        }\n      ]\n    });\n\n    if (!mail) {\n      return null;\n    }\n\n    if (mail.__typename === \"ErrorAccessDenied\") {\n      return mail;\n    }\n\n    if (!mail.mail) {\n      return null;\n    }\n\n    const result = convertInternalMailToExternal(mail.mail, this.#keys);\n\n    if (!result) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async recover({\n    mailId\n  }: {\n    mailId: string;\n  }): Promise<\n    SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null\n  > {\n    const { recoverMail } = await this.#thunder(\"mutation\")({\n      recoverMail: [\n        { mailId },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on RecoverMailResponse\": {\n            __typename: true,\n            recoverMail: true\n          }\n        }\n      ]\n    });\n\n    if (!recoverMail) {\n      return null;\n    }\n\n    if (recoverMail.__typename === \"ErrorAccessDenied\") {\n      return recoverMail;\n    }\n\n    if (recoverMail.__typename === \"ErrorBasic\") {\n      return recoverMail;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: recoverMail.recoverMail\n    };\n  }\n\n  async deletedMails({\n    mailType\n  }: {\n    mailType: MailType;\n  }): Promise<SuccessResponse<Mail[]> | ErrorAccessDenied | null> {\n    const { deletedMails } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      deletedMails: [\n        { mailType },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DeletedMailsResponse\": {\n            __typename: true,\n            deletedMails: mailSelector\n          }\n        }\n      ]\n    });\n\n    if (!deletedMails) {\n      return null;\n    }\n\n    if (deletedMails.__typename === \"ErrorAccessDenied\") {\n      return deletedMails;\n    }\n\n    const mails = new Array<Mail>();\n\n    for (const m of deletedMails.deletedMails) {\n      const mail = convertInternalMailToExternal(m, this.#keys);\n      if (mail) {\n        mails.push(mail);\n      }\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: mails\n    };\n  }\n\n  async create(\n    data: NewMail,\n    customMessage?: string | null | undefined\n  ): Promise<SuccessResponse<boolean> | ErrorBasic | ErrorAccessDenied | null> {\n    const mail = await this.createDraft(data);\n    if (!mail) {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n\n    if (mail.__typename === \"ErrorBasic\") {\n      return mail;\n    }\n\n    if (mail.__typename === \"ErrorAccessDenied\") {\n      return mail;\n    }\n\n    const result = await this.sendDraft(\n      mail.data.mailIntegrityId,\n      customMessage\n    );\n\n    if (!result) {\n      return null;\n    }\n\n    if (result.__typename === \"ErrorAccessDenied\") {\n      return result;\n    }\n\n    if (result.__typename === \"ErrorBasic\") {\n      return result;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result.data\n    };\n  }\n\n  async waitingReceivedMails(): Promise<\n    SuccessResponse<WaitingReceivedMail[]> | ErrorNotFound | null\n  > {\n    const { user } = await this.#thunder(\"query\")({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              waitingReceivedMails: {\n                date: true,\n                attachmentsCount: true,\n                sender: {\n                  id: true,\n                  firstname: true,\n                  lastname: true,\n                  email: true,\n                  publicKey: true\n                },\n                recipients: {\n                  id: true,\n                  firstname: true,\n                  lastname: true,\n                  email: true,\n                  publicKey: true\n                },\n                temporaryRecipients: {\n                  email: true\n                }\n              }\n            }\n          }\n        }\n      ]\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (!user.user) {\n      return null;\n    }\n\n    const result = user.user.waitingReceivedMails.map(m => ({\n      id: generate(),\n      ...m,\n      date: new Date(m.date as string)\n    }));\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async updateDraft(\n    draftId: string,\n    { body, subject, files, recipientsIds, replyTo }: Partial<NewMail>\n  ): Promise<\n    | SuccessResponse<DraftMail>\n    | ErrorNotFound\n    | ErrorAccessDenied\n    | ErrorBasic\n    | null\n  > {\n    const drafts = await this.draftMails();\n    if (!drafts) {\n      return null;\n    }\n\n    if (drafts.__typename !== \"SuccessResponse\") {\n      return drafts;\n    }\n    const draft = drafts.data.find(d => d.mailIntegrityId === draftId);\n    if (!draft) {\n      throw new Error(`Invalid draft ${draftId}`);\n    }\n    let hashKey: string | null = null;\n    let hash: string | null = null;\n    if (body || subject) {\n      hashKey = sodium.randombytes_buf(\n        sodium.crypto_generichash_KEYBYTES,\n        \"hex\"\n      );\n      hash = sodium.crypto_generichash(\n        sodium.crypto_generichash_BYTES,\n        JSON.stringify({ body, subject }),\n        hashKey,\n        \"hex\"\n      );\n    }\n    const senderFiles = new Array<MailFileInput>();\n    if (files) {\n      for (const f of files) {\n        let file = filesCache.get(f.id);\n        if (!file) {\n          await this.#client.cloud.file({ id: f.id });\n          file = filesCache.get(f.id);\n          if (!file) {\n            throw new Error(`File ${f.name} (${f.id}) does not exists`);\n          }\n        }\n        senderFiles.push({\n          id: file.id,\n          fileKey: sodium.to_hex(\n            encryptCryptoBox(\n              sodium.from_string(file.key),\n              this.#keys.publicKey,\n              this.#keys.privateKey\n            )\n          ),\n          name: sodium.to_hex(\n            encryptCryptoBox(\n              sodium.from_string(f.name),\n              this.#keys.publicKey,\n              this.#keys.privateKey\n            )\n          )\n        });\n      }\n    }\n\n    const { updateDraftMail } = await this.#thunder(\"mutation\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      updateDraftMail: [\n        {\n          draftId,\n          recipients: recipientsIds,\n          replyTo,\n          body: body\n            ? sodium.to_hex(\n                encryptCryptoBox(\n                  sodium.from_string(body),\n                  this.#keys.publicKey,\n                  this.#keys.privateKey\n                )\n              )\n            : null,\n          subject: subject\n            ? sodium.to_hex(\n                encryptCryptoBox(\n                  sodium.from_string(subject),\n                  this.#keys.publicKey,\n                  this.#keys.privateKey\n                )\n              )\n            : null,\n          senderFiles,\n          hash,\n          hashKey\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UpdateDraftMailResponse\": {\n            __typename: true,\n            updateDraftMail: mailSelector\n          }\n        }\n      ]\n    });\n\n    if (!updateDraftMail) {\n      return null;\n    }\n\n    if (updateDraftMail.__typename === \"ErrorAccessDenied\") {\n      return updateDraftMail;\n    }\n\n    if (updateDraftMail.__typename === \"ErrorBasic\") {\n      return updateDraftMail;\n    }\n\n    if (!updateDraftMail.updateDraftMail) {\n      return null;\n    }\n\n    const result = convertInternalMailToExternal(\n      updateDraftMail.updateDraftMail,\n      this.#keys\n    ) as DraftMail;\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async deleteDraft(\n    draftId: string\n  ): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null> {\n    const { deleteDraftMail } = await this.#thunder(\"mutation\")({\n      deleteDraftMail: [\n        {\n          draftId\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DeleteDraftMailResponse\": {\n            __typename: true,\n            deleteDraftMail: true\n          }\n        }\n      ]\n    });\n\n    if (!deleteDraftMail) {\n      return null;\n    }\n\n    if (deleteDraftMail.__typename === \"ErrorAccessDenied\") {\n      return deleteDraftMail;\n    }\n\n    if (!deleteDraftMail.deleteDraftMail) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: deleteDraftMail.deleteDraftMail ?? false\n    };\n  }\n\n  async deleteTrash({\n    ids\n  }: {\n    ids: Array<string>;\n  }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null> {\n    const { deleteMailTrash } = await this.#thunder(\"mutation\")({\n      deleteMailTrash: [\n        {\n          ids\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DeleteMailTrashResponse\": {\n            __typename: true,\n            deleteMailTrash: true\n          }\n        }\n      ]\n    });\n\n    if (!deleteMailTrash) {\n      return null;\n    }\n\n    if (deleteMailTrash.__typename === \"ErrorAccessDenied\") {\n      return deleteMailTrash;\n    }\n\n    if (!deleteMailTrash.deleteMailTrash) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: deleteMailTrash.deleteMailTrash\n    };\n  }\n\n  async emptyTrash(): Promise<\n    SuccessResponse<boolean> | ErrorAccessDenied | null\n  > {\n    const { emptyMailTrash } = await this.#thunder(\"mutation\")({\n      emptyMailTrash: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on EmptyMailTrashResponse\": {\n          __typename: true,\n          emptyMailTrash: true\n        }\n      }\n    });\n\n    if (!emptyMailTrash) {\n      return null;\n    }\n\n    if (emptyMailTrash.__typename === \"ErrorAccessDenied\") {\n      return emptyMailTrash;\n    }\n\n    if (!emptyMailTrash.emptyMailTrash) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: emptyMailTrash.emptyMailTrash\n    };\n  }\n\n  async delete({\n    mailId\n  }: {\n    mailId: string;\n  }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null> {\n    const { deleteMail } = await this.#thunder(\"mutation\")({\n      deleteMail: [\n        {\n          mailId\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DeleteMailResponse\": {\n            __typename: true,\n            deleteMail: true\n          }\n        }\n      ]\n    });\n\n    if (!deleteMail) {\n      return null;\n    }\n\n    if (deleteMail.__typename === \"ErrorAccessDenied\") {\n      return deleteMail;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: deleteMail.deleteMail\n    };\n  }\n\n  async sendDraft(\n    draftId: string,\n    customMessage?: string | null | undefined\n  ): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null> {\n    const drafts = await this.draftMails();\n\n    if (!drafts) {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n    if (drafts.__typename !== \"SuccessResponse\") {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n\n    const draft = drafts.data.find(d => d.mailIntegrityId === draftId);\n    if (!draft) {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n    const recipients = new Array<MailRecipientInput>();\n\n    const temporaryRecipients = new Array<string>();\n\n    for (const { email } of draft.temporaryRecipients) {\n      if (!email) {\n        continue;\n      }\n      const input = await this._eachUser(\n        draft.files,\n        draft.subject,\n        draft.body,\n        email\n      );\n\n      if (!input) {\n        temporaryRecipients.push(email);\n      } else {\n        recipients.push(input);\n      }\n    }\n\n    for (const { id } of draft.recipients) {\n      const input = await this._eachUser(\n        draft.files,\n        draft.subject,\n        draft.body,\n        id\n      );\n\n      if (!input) {\n        temporaryRecipients.push(id);\n      } else {\n        recipients.push(input);\n      }\n    }\n\n    const { sendDraftMail } = await this.#thunder(\"mutation\")({\n      sendDraftMail: [\n        {\n          temporaryRecipients,\n          recipients,\n          draftMailId: draft.mailIntegrityId,\n          customMessage\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on SendDraftMailResponse\": {\n            __typename: true,\n            sendDraftMail: true\n          }\n        }\n      ]\n    });\n\n    if (!sendDraftMail) {\n      return null;\n    }\n\n    if (sendDraftMail.__typename === \"ErrorAccessDenied\") {\n      return sendDraftMail;\n    }\n\n    if (sendDraftMail.__typename === \"ErrorBasic\") {\n      return sendDraftMail;\n    }\n\n    if (!sendDraftMail.sendDraftMail) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: sendDraftMail.sendDraftMail\n    };\n  }\n\n  async sendWaitingEmails(): Promise<\n    SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null\n  > {\n    // TODO opti this\n    const mails = await this.sentMails();\n\n    if (!mails) {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n    if (mails.__typename !== \"SuccessResponse\") {\n      return {\n        __typename: \"SuccessResponse\",\n        data: false\n      };\n    }\n    const filtered = mails.data.filter(m => m.temporaryRecipients.length > 0);\n\n    for (const mail of filtered) {\n      for (const { email } of mail.temporaryRecipients) {\n        if (!email) {\n          continue;\n        }\n        try {\n          const input = await this._eachUser(\n            mail.files,\n            mail.subject,\n            mail.body,\n            email\n          );\n\n          if (!input) {\n            continue;\n          }\n          await this.#thunder(\"mutation\")({\n            sendOneMail: [\n              {\n                mailIntegrityId: mail.mailIntegrityId,\n                recipient: input\n              },\n              {\n                \"...on ErrorAccessDenied\": {\n                  __typename: true,\n                  message: true\n                },\n                \"...on ErrorBasic\": {\n                  __typename: true,\n                  message: true\n                },\n                \"...on RecoverNodeResponse\": {\n                  __typename: true,\n                  recoverNode: true\n                }\n              }\n            ]\n          });\n        } catch {\n          continue;\n        }\n      }\n    }\n    return {\n      __typename: \"SuccessResponse\",\n      data: false\n    };\n  }\n\n  async createDraft({\n    body,\n    subject,\n    files,\n    recipientsIds,\n    replyTo\n  }: NewMail): Promise<\n    SuccessResponse<DraftMail> | ErrorAccessDenied | ErrorBasic | null\n  > {\n    const hashKey = sodium.randombytes_buf(\n      sodium.crypto_generichash_KEYBYTES,\n      \"hex\"\n    );\n    const hash = sodium.crypto_generichash(\n      sodium.crypto_generichash_BYTES,\n      JSON.stringify({ body, subject }),\n      hashKey,\n      \"hex\"\n    );\n    const senderFiles = new Array<MailFileInput>();\n    for (const f of files) {\n      let file = filesCache.get(f.id);\n      if (!file) {\n        await this.#client.cloud.file({ id: f.id });\n        file = filesCache.get(f.id);\n        if (!file) {\n          throw new Error(`File ${f.name} (${f.id}) does not exists`);\n        }\n      }\n      senderFiles.push({\n        id: file.id,\n        fileKey: sodium.to_hex(\n          encryptCryptoBox(\n            sodium.from_string(file.key),\n            this.#keys.publicKey,\n            this.#keys.privateKey\n          )\n        ),\n        name: sodium.to_hex(\n          encryptCryptoBox(\n            sodium.from_string(f.name),\n            this.#keys.publicKey,\n            this.#keys.privateKey\n          )\n        )\n      });\n    }\n\n    const { createDraftMail } = await this.#thunder(\"mutation\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      createDraftMail: [\n        {\n          recipients: recipientsIds,\n          replyTo,\n          body: sodium.to_hex(\n            encryptCryptoBox(\n              sodium.from_string(body),\n              this.#keys.publicKey,\n              this.#keys.privateKey\n            )\n          ),\n          subject: sodium.to_hex(\n            encryptCryptoBox(\n              sodium.from_string(subject),\n              this.#keys.publicKey,\n              this.#keys.privateKey\n            )\n          ),\n          senderFiles,\n          hash,\n          hashKey\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on CreateDraftMailResponse\": {\n            __typename: true,\n            createDraftMail: mailSelector\n          }\n        }\n      ]\n    });\n\n    if (!createDraftMail) {\n      return null;\n    }\n\n    if (createDraftMail.__typename === \"ErrorAccessDenied\") {\n      return createDraftMail;\n    }\n\n    if (createDraftMail.__typename === \"ErrorBasic\") {\n      return createDraftMail;\n    }\n\n    if (!createDraftMail.createDraftMail) {\n      return null;\n    }\n\n    const result = convertInternalMailToExternal(\n      createDraftMail.createDraftMail,\n      this.#keys\n    ) as DraftMail;\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async read({\n    mailId\n  }: {\n    mailId: string;\n  }): Promise<\n    | SuccessResponse<boolean>\n    | ErrorAccessDenied\n    | ErrorBasic\n    | ErrorNotFound\n    | null\n  > {\n    const { readMail } = await this.#thunder(\"mutation\")({\n      readMail: [\n        { mailId },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ReadMailResponse\": {\n            __typename: true,\n            readMail: true\n          }\n        }\n      ]\n    });\n\n    if (!readMail) {\n      return null;\n    }\n\n    if (readMail.__typename === \"ErrorAccessDenied\") {\n      return readMail;\n    }\n\n    if (readMail.__typename === \"ErrorBasic\") {\n      return readMail;\n    }\n\n    if (readMail.__typename === \"ErrorNotFound\") {\n      return readMail;\n    }\n\n    if (!readMail.readMail) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: readMail.readMail\n    };\n  }\n\n  async unread({\n    mailId\n  }: {\n    mailId: string;\n  }): Promise<\n    | SuccessResponse<boolean>\n    | ErrorAccessDenied\n    | ErrorBasic\n    | ErrorNotFound\n    | null\n  > {\n    const { unreadMail } = await this.#thunder(\"mutation\")({\n      unreadMail: [\n        { mailId },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UnreadMailResponse\": {\n            __typename: true,\n            unreadMail: true\n          }\n        }\n      ]\n    });\n\n    if (!unreadMail) {\n      return null;\n    }\n\n    if (unreadMail.__typename === \"ErrorAccessDenied\") {\n      return unreadMail;\n    }\n\n    if (unreadMail.__typename === \"ErrorBasic\") {\n      return unreadMail;\n    }\n\n    if (unreadMail.__typename === \"ErrorNotFound\") {\n      return unreadMail;\n    }\n\n    if (!unreadMail.unreadMail) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: unreadMail.unreadMail\n    };\n  }\n\n  async receivedMails(): Promise<\n    SuccessResponse<ReceivedMail[]> | ErrorNotFound | null\n  > {\n    const { user } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              receivedMails: mailSelector\n            }\n          }\n        }\n      ]\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (!user.user) {\n      return null;\n    }\n\n    // TODO get actual mails on this app only\n\n    const receivedMails = new Array<ReceivedMail>();\n\n    for (const m of user.user.receivedMails) {\n      const mail = convertInternalMailToExternal(m, this.#keys);\n      if (mail) {\n        receivedMails.push(mail as ReceivedMail);\n      }\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: receivedMails\n    };\n  }\n\n  async sentMails(): Promise<\n    SuccessResponse<SentMail[]> | ErrorNotFound | null\n  > {\n    const { user } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              sentMails: mailSelector\n            }\n          }\n        }\n      ]\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (!user.user) {\n      return null;\n    }\n\n    // TODO get actual mails on this app only\n\n    const sentMails = new Array<SentMail>();\n\n    for (const m of user.user.sentMails) {\n      const mail = convertInternalMailToExternal(m, this.#keys);\n      if (mail) {\n        sentMails.push(mail as SentMail);\n      }\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: sentMails\n    };\n  }\n\n  async draftMails(): Promise<\n    SuccessResponse<DraftMail[]> | ErrorNotFound | null\n  > {\n    const { user } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              draftMails: mailSelector\n            }\n          }\n        }\n      ]\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (!user.user) {\n      return null;\n    }\n\n    // TODO get actual mails on this app only\n\n    const draftMails = new Array<DraftMail>();\n\n    for (const m of user.user.draftMails) {\n      const draft = convertInternalMailToExternal(m, this.#keys) as DraftMail;\n      if (draft) {\n        draftMails.push(draft);\n      }\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: draftMails\n    };\n  }\n\n  async unreadReceivedMailsCount(): Promise<\n    SuccessResponse<number> | ErrorAccessDenied | null\n  > {\n    const { unreadReceivedMailsCount } = await this.#thunder(\"query\")({\n      unreadReceivedMailsCount: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on UnreadReceivedMailsCountResponse\": {\n          __typename: true,\n          count: true\n        }\n      }\n    });\n\n    if (!unreadReceivedMailsCount) {\n      return null;\n    }\n\n    if (unreadReceivedMailsCount.__typename === \"ErrorAccessDenied\") {\n      return unreadReceivedMailsCount;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: unreadReceivedMailsCount.count\n    };\n  }\n\n  private _eachUser = async (\n    files: { id: string; name: string }[],\n    subject: string,\n    body: string,\n    idOrMail: string\n  ): Promise<MailRecipientInput | null> => {\n    let u = usersCache.get(idOrMail);\n\n    if (!u || !(\"publicKey\" in u)) {\n      try {\n        const req = await this.#client.user({\n          userId: idOrMail,\n          withPublicKey: true\n        });\n        if (!req) {\n          return null;\n        }\n        if (req.__typename !== \"SuccessResponse\") {\n          return null;\n        }\n        u = req.data;\n      } catch {\n        return null;\n      }\n\n      if (!u) {\n        return null;\n      }\n    }\n\n    if (!(\"publicKey\" in u)) {\n      throw new Error(`User ${idOrMail} have no public key`);\n    }\n\n    const recipientsFiles = new Array<MailFileInput>();\n\n    for (const f of files) {\n      let fileInHistory = filesCache.get(f.id);\n      if (!fileInHistory) {\n        await this.#client.cloud.file({ id: f.id });\n        fileInHistory = filesCache.get(f.id);\n        if (!fileInHistory) {\n          throw new Error(`File ${f.name} (${f.id}) does not exists`);\n        }\n      }\n      const key = fileInHistory.key;\n      recipientsFiles.push({\n        id: f.id,\n        name: sodium.to_hex(\n          encryptCryptoBox(\n            sodium.from_string(f.name),\n            u.publicKey,\n            this.#keys.privateKey\n          )\n        ),\n        fileKey: sodium.to_hex(\n          encryptCryptoBox(\n            sodium.from_hex(key),\n            u.publicKey,\n            this.#keys.privateKey\n          )\n        )\n      });\n    }\n\n    return {\n      recipientId: u.id,\n      body: sodium.to_hex(\n        encryptCryptoBox(\n          sodium.from_string(body),\n          u.publicKey,\n          this.#keys.privateKey\n        )\n      ),\n      subject: sodium.to_hex(\n        encryptCryptoBox(\n          sodium.from_string(subject),\n          u.publicKey,\n          this.#keys.privateKey\n        )\n      ),\n      files: recipientsFiles\n    };\n  };\n}\n"],"mappings":"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"}