@secrecy/lib 1.0.0-dev.9 → 1.0.1

package/dist/client/SecrecyMailClient.js

@@ -0,0 +1,1022 @@
+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.fileMetadata({
+            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.fileMetadata({
+            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) {
+    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.deleteDraftMail ?? 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.fileMetadata({
+          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","fileMetadata","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","file","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.fileMetadata({ 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.fileMetadata({ 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.fileMetadata({ 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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"}