internxt-crypto 0.0.8-alpha → 0.0.10-alpha

package/dist/email-search.js

@@ -0,0 +1,605 @@
+'use strict';
+
+var idb = require('idb');
+var blake3_js = require('@noble/hashes/blake3.js');
+var utils_js$1 = require('@noble/hashes/utils.js');
+var utils_js = require('@noble/post-quantum/utils.js');
+require('uuid');
+var flexsearch = require('flexsearch');
+
+// src/email-search/indexedDB.ts
+
+// src/constants.ts
+var AES_ALGORITHM = "AES-GCM";
+var AES_KEY_BIT_LENGTH = 256;
+var AUX_LEN = 128;
+var IV_LEN_BYTES = 16;
+var KEY_FORMAT = "raw";
+var CONTEXT_INDEX = "CRYPTO library 2025-07-30 17:20:00 key for protecting current search indices";
+var MAX_CACHE_SIZE = 6e8;
+var MAX_EMAIL_PER_BATCH = 100;
+var DB_LABEL = "email";
+var DB_VERSION = 1;
+function getBytesFromString(bytes, value) {
+  return blake3_js.blake3(utils_js$1.utf8ToBytes(value), { dkLen: bytes });
+}
+
+// src/symmetric-crypto/keys.ts
+async function importSymmetricCryptoKey(keyData) {
+  return crypto.subtle.importKey(
+    KEY_FORMAT,
+    new Uint8Array(keyData),
+    {
+      name: AES_ALGORITHM,
+      length: AES_KEY_BIT_LENGTH
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+async function createNISTbasedIV(freeField) {
+  try {
+    if (!freeField) {
+      return utils_js.randomBytes(IV_LEN_BYTES);
+    }
+    const iv = new Uint8Array(16);
+    const randFiled = utils_js.randomBytes(12);
+    iv.set(randFiled, 0);
+    const freeFiledFixedLength = await getBytesFromString(4, freeField);
+    iv.set(freeFiledFixedLength, 12);
+    return iv;
+  } catch (error) {
+    throw new Error("Failed to create IV", { cause: error });
+  }
+}
+async function makeAuxFixedLength(aux) {
+  return getBytesFromString(AUX_LEN / 8, aux);
+}
+async function encryptMessage(message, encryptionKey, iv, additionalData) {
+  try {
+    const encrypted = await crypto.subtle.encrypt(
+      { name: AES_ALGORITHM, iv, additionalData },
+      encryptionKey,
+      message
+    );
+    return new Uint8Array(encrypted);
+  } catch (error) {
+    throw new Error("Failed to encrypt symmetrically", { cause: error });
+  }
+}
+async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
+  try {
+    const decrypted = await crypto.subtle.decrypt(
+      { name: AES_ALGORITHM, iv, additionalData },
+      encryptionKey,
+      ciphertext
+    );
+    return new Uint8Array(decrypted);
+  } catch (error) {
+    throw new Error("Failed to decrypt symmetrically", { cause: error });
+  }
+}
+
+// src/symmetric-crypto/aes.ts
+async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
+  try {
+    const iv = await createNISTbasedIV(freeField);
+    const additionalData = await makeAuxFixedLength(aux);
+    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
+    return { ciphertext, iv };
+  } catch (error) {
+    throw new Error("Failed to encrypt symmetrically", { cause: error });
+  }
+}
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+  try {
+    const additionalData = await makeAuxFixedLength(aux);
+    const result = await decryptMessage(
+      encryptedMessage.ciphertext,
+      encryptedMessage.iv,
+      encryptionKey,
+      additionalData
+    );
+    return result;
+  } catch (error) {
+    throw new Error("Failed to decrypt symmetrically", { cause: error });
+  }
+}
+function UTF8ToUint8(str) {
+  return new TextEncoder().encode(str);
+}
+function uint8ToUTF8(array) {
+  return new TextDecoder().decode(array);
+}
+
+// src/email-crypto/converters.ts
+function emailBodyToBinary(body) {
+  try {
+    const json = JSON.stringify(body);
+    return UTF8ToUint8(json);
+  } catch (error) {
+    throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
+  }
+}
+function binaryToEmailBody(array) {
+  try {
+    const json = uint8ToUTF8(array);
+    const email = JSON.parse(json);
+    return email;
+  } catch (error) {
+    throw new Error("Failed to convert Uint8Array to EmailBody", { cause: error });
+  }
+}
+function emailToBinary(email) {
+  try {
+    const json = JSON.stringify(email);
+    return UTF8ToUint8(json);
+  } catch (error) {
+    throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
+  }
+}
+function deriveSymmetricKeyFromContext(context, baseKey) {
+  return blake3_js.blake3(baseKey, { context: UTF8ToUint8(context) });
+}
+async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
+  try {
+    if (baseKey.length != AES_KEY_BIT_LENGTH / 8) {
+      throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
+    }
+    if (!context) ;
+    const keyBytes = deriveSymmetricKeyFromContext(context, baseKey);
+    const key = await importSymmetricCryptoKey(keyBytes);
+    return key;
+  } catch (error) {
+    throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
+  }
+}
+
+// src/email-crypto/core.ts
+async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey, aux, emailID) {
+  try {
+    const binaryEmail = emailBodyToBinary(emailBody);
+    const ciphertext = await encryptSymmetrically(encryptionKey, binaryEmail, aux, emailID);
+    return ciphertext;
+  } catch (error) {
+    throw new Error("Failed to symmetrically encrypt email with the given key", { cause: error });
+  }
+}
+async function decryptEmailSymmetrically(emailCiphertext, encryptionKey, aux) {
+  try {
+    const binaryEmail = await decryptSymmetrically(encryptionKey, emailCiphertext, aux);
+    const body = binaryToEmailBody(binaryEmail);
+    return body;
+  } catch (error) {
+    throw new Error("Failed to symmetrically decrypt email", { cause: error });
+  }
+}
+function getAux(params) {
+  try {
+    const { subject, replyToEmailID, sender, recipients } = params;
+    const aux = JSON.stringify({ subject, replyToEmailID, sender, recipients });
+    return aux;
+  } catch (error) {
+    throw new Error("Failed to create aux", { cause: error });
+  }
+}
+
+// src/email-search/indexedDB.ts
+var getDatabaseName = (userID) => {
+  return `ES:${userID}:DB`;
+};
+var openDatabase = async (userID) => {
+  try {
+    const dbName = getDatabaseName(userID);
+    return idb.openDB(dbName, DB_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains(DB_LABEL)) {
+          const store = db.createObjectStore(DB_LABEL, { keyPath: "id" });
+          store.createIndex("byTime", "params.createdAt");
+        }
+      }
+    });
+  } catch (error) {
+    throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
+  }
+};
+var closeDatabase = (esDB) => {
+  return esDB.close();
+};
+var deleteDatabase = async (userID) => {
+  const dbName = getDatabaseName(userID);
+  return idb.deleteDB(dbName);
+};
+var deriveIndexKey = async (baseKey) => {
+  return deriveSymmetricCryptoKeyFromContext(CONTEXT_INDEX, baseKey);
+};
+var encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
+  try {
+    const aux = getAux(newEmailToStore.params);
+    const ciphertext = await encryptEmailContentSymmetricallyWithKey(
+      newEmailToStore.body,
+      indexKey,
+      aux,
+      newEmailToStore.id
+    );
+    const encryptedEmail = { content: ciphertext, params: newEmailToStore.params, id: newEmailToStore.id };
+    await esDB.put(DB_LABEL, encryptedEmail);
+  } catch (error) {
+    throw new Error("Cannot encrypt and add the given email to the database", { cause: error });
+  }
+};
+var encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
+  try {
+    const encryptedEmails = await Promise.all(
+      newEmailsToStore.map(async (email) => {
+        const aux = getAux(email.params);
+        const ciphertext = await encryptEmailContentSymmetricallyWithKey(email.body, indexKey, aux, email.id);
+        return { content: ciphertext, params: email.params, id: email.id };
+      })
+    );
+    const tr = esDB.transaction(DB_LABEL, "readwrite");
+    await Promise.all([...encryptedEmails.map((encEmail) => tr.store.put(encEmail)), tr.done]);
+  } catch (error) {
+    throw new Error("Cannot encrypt and add emails to the database", { cause: error });
+  }
+};
+var decryptEmail = async (indexKey, encryptedEmail) => {
+  try {
+    const aux = getAux(encryptedEmail.params);
+    const email = await decryptEmailSymmetrically(encryptedEmail.content, indexKey, aux);
+    return { body: email, params: encryptedEmail.params, id: encryptedEmail.id };
+  } catch (error) {
+    throw new Error("Cannot decrypt the given email", { cause: error });
+  }
+};
+var getAndDecryptEmail = async (emailID, indexKey, esDB) => {
+  try {
+    const encryptedEmail = await esDB.get(DB_LABEL, emailID);
+    if (!encryptedEmail) {
+      throw new Error(`DB cannot find email with id ${emailID}`);
+    }
+    return decryptEmail(indexKey, encryptedEmail);
+  } catch (error) {
+    throw new Error(`Cannot fetch the email ${emailID} from the database`, { cause: error });
+  }
+};
+var getAndDecryptAllEmails = async (indexKey, esDB) => {
+  try {
+    const encryptedEmails = await esDB.getAll(DB_LABEL);
+    const decryptedEmails = await Promise.all(
+      encryptedEmails.map(async (encEmail) => {
+        const aux = getAux(encEmail.params);
+        const body = await decryptEmailSymmetrically(encEmail.content, indexKey, aux);
+        return { body, params: encEmail.params, id: encEmail.id };
+      })
+    );
+    return decryptedEmails.filter((email) => email !== null);
+  } catch (error) {
+    throw new Error("Cannot fetch and decrypt all emails from the database", { cause: error });
+  }
+};
+var deleteEmail = async (emailID, esDB) => {
+  await esDB.delete(DB_LABEL, emailID);
+};
+var getEmailCount = async (esDB) => {
+  return await esDB.count(DB_LABEL);
+};
+var deleteOldestEmails = async (emailsToDelete, esDB) => {
+  try {
+    const tx = esDB.transaction(DB_LABEL, "readwrite");
+    const index = tx.store.index("byTime");
+    let cursor = await index.openCursor();
+    let deletedCount = 0;
+    while (cursor && deletedCount < emailsToDelete) {
+      await cursor.delete();
+      deletedCount++;
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  } catch (error) {
+    throw new Error(`Cannot delete ${emailsToDelete} oldests emails from the database`, { cause: error });
+  }
+};
+var enforceMaxEmailNumber = async (esDB, max) => {
+  try {
+    const currentCount = await getEmailCount(esDB);
+    if (currentCount <= max) {
+      return;
+    }
+    await deleteOldestEmails(currentCount - max, esDB);
+  } catch (error) {
+    throw new Error(`Cannot enforce the maximum of ${max} emails on the database`, { cause: error });
+  }
+};
+var fetchEmails = async (esDB, indexKey, direction) => {
+  try {
+    const tx = esDB.transaction(DB_LABEL, "readonly");
+    const index = tx.store.index("byTime");
+    const encryptedEmails = [];
+    let cursor = await index.openCursor(null, direction);
+    while (cursor) {
+      encryptedEmails.push(cursor.value);
+      cursor = await cursor.continue();
+    }
+    const emails = await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
+    return emails;
+  } catch (error) {
+    throw new Error("Cannot fetch emails from database", { cause: error });
+  }
+};
+var getAllEmailsSortedNewestFirst = async (esDB, indexKey) => {
+  return fetchEmails(esDB, indexKey, "prev");
+};
+var getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
+  return fetchEmails(esDB, indexKey, "next");
+};
+var getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
+  try {
+    const tx = esDB.transaction(DB_LABEL, "readonly");
+    const index = tx.store.index("byTime");
+    const encryptedEmails = [];
+    let cursor;
+    if (startCursor) {
+      const range = IDBKeyRange.upperBound(startCursor, true);
+      cursor = await index.openCursor(range, "prev");
+    } else {
+      cursor = await index.openCursor(null, "prev");
+    }
+    let count = 0;
+    let nextCursor;
+    while (cursor && count < batchSize) {
+      encryptedEmails.push(cursor.value);
+      nextCursor = cursor.key;
+      count++;
+      cursor = await cursor.continue();
+    }
+    const emails = await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
+    return {
+      emails,
+      nextCursor: count === batchSize ? nextCursor : void 0
+    };
+  } catch (error) {
+    throw new Error(`Cannot fetch email batch of ${batchSize} from the database`, { cause: error });
+  }
+};
+
+// src/email-search/mailCache.ts
+function sizeOfEmail(email) {
+  return emailToBinary(email).byteLength;
+}
+function createEmptyCache() {
+  return {
+    esCache: /* @__PURE__ */ new Map(),
+    cacheSize: 0,
+    isCacheLimited: false,
+    isCacheReady: true
+  };
+}
+var createCacheFromDB = async (indexKey, esDB) => {
+  const esCache = createEmptyCache();
+  esCache.isCacheReady = false;
+  try {
+    const count = await getEmailCount(esDB);
+    if (!count) {
+      esCache.isCacheReady = true;
+      return esCache;
+    }
+    if (count <= MAX_EMAIL_PER_BATCH) {
+      const emails = await getAllEmailsSortedNewestFirst(esDB, indexKey);
+      addEmailsToCache(emails, esCache);
+    } else {
+      let nextCursor = void 0;
+      let cacheFull = false;
+      while (!cacheFull) {
+        const { emails, nextCursor: newCursor } = await getEmailBatch(
+          esDB,
+          indexKey,
+          MAX_EMAIL_PER_BATCH,
+          nextCursor
+        );
+        if (!newCursor || !emails.length) break;
+        nextCursor = newCursor;
+        const success = addEmailsToCache(emails, esCache);
+        if (!success) cacheFull = true;
+      }
+    }
+    return esCache;
+  } catch (error) {
+    throw new Error(`Email caching failed: ${error}`);
+  }
+};
+var getEmailFromCache = async (emailID, esCache) => {
+  const email = esCache.esCache.get(emailID);
+  if (!email) {
+    throw new Error(`Email not found in cache for ID: ${emailID}`);
+  }
+  return email;
+};
+var deleteEmailFromCache = async (emailID, esCache) => {
+  try {
+    const email = await getEmailFromCache(emailID, esCache);
+    const size = sizeOfEmail(email);
+    const removed = esCache.esCache.delete(emailID);
+    if (removed) esCache.cacheSize -= size;
+  } catch (error) {
+    throw new Error(`Failed to delete email with ID ${emailID}`, { cause: error });
+  }
+};
+function addEmailsToCache(emails, esCache) {
+  try {
+    for (const email of emails) {
+      const result = addEmailToCache(email, esCache);
+      if (!result.success) return result;
+    }
+    return { success: true };
+  } catch (error) {
+    throw new Error("Failed to add emails to the cache", { cause: error });
+  }
+}
+var addEmailToCache = (email, esCache) => {
+  try {
+    if (esCache.esCache.has(email.id)) {
+      return { success: false, reason: "email already exists in cache" };
+    }
+    const emailSize = sizeOfEmail(email);
+    if (esCache.cacheSize + emailSize > MAX_CACHE_SIZE) {
+      esCache.isCacheLimited = true;
+      return { success: false, reason: "hit cache limit" };
+    }
+    esCache.esCache.set(email.id, email);
+    esCache.cacheSize += emailSize;
+    return { success: true };
+  } catch (error) {
+    throw new Error("Failed to add email to the cache", { cause: error });
+  }
+};
+var SUBJECT_OPTIONS = {
+  preset: "match",
+  tokenize: "forward",
+  resolution: 9,
+  minlength: 2,
+  optimize: true,
+  fastupdate: true,
+  cache: true
+};
+var BODY_OPTIONS = {
+  ...SUBJECT_OPTIONS,
+  minlength: 3,
+  resolution: 6
+};
+var FROM_OPTIONS = {
+  ...SUBJECT_OPTIONS,
+  tokenize: "strict",
+  minlength: 1
+};
+var TO_OPTIONS = {
+  ...SUBJECT_OPTIONS,
+  tokenize: "strict",
+  minlength: 1
+};
+var createSearchIndex = () => ({
+  subjectIndex: new flexsearch.Index(SUBJECT_OPTIONS),
+  bodyIndex: new flexsearch.Index(BODY_OPTIONS),
+  fromIndex: new flexsearch.Index(FROM_OPTIONS),
+  toIndex: new flexsearch.Index(TO_OPTIONS),
+  isReady: false
+});
+var addEmailToSearchIndex = (email, searchIndex) => {
+  try {
+    const emailId = email.id;
+    if (email.params.subject) {
+      searchIndex.subjectIndex.add(emailId, email.params.subject);
+    }
+    if (email.body?.text) {
+      searchIndex.bodyIndex.add(emailId, email.body.text);
+    }
+    if (email.params.sender) {
+      const senderText = `${email.params.sender.name || ""} ${email.params.sender.email || ""}`.trim();
+      searchIndex.fromIndex.add(emailId, senderText);
+    }
+    const recipientsList = email.params.recipients?.length ? email.params.recipients : [email.params.recipient];
+    const recipientsText = recipientsList.map((recipient) => `${recipient.name || ""} ${recipient.email || ""}`.trim()).join(" ");
+    searchIndex.toIndex.add(emailId, recipientsText);
+  } catch (error) {
+    throw new Error("Failed to add email to the search index", { cause: error });
+  }
+};
+var removeEmailFromSearchIndex = (emailID, searchIndex) => {
+  try {
+    searchIndex.subjectIndex.remove(emailID);
+    searchIndex.bodyIndex.remove(emailID);
+    searchIndex.fromIndex.remove(emailID);
+    searchIndex.toIndex.remove(emailID);
+  } catch (error) {
+    throw new Error(`Failed to remove email with ID ${emailID} from the search index`, { cause: error });
+  }
+};
+var buildSearchIndexFromCache = async (esCache) => {
+  try {
+    const searchIndex = createSearchIndex();
+    searchIndex.isReady = false;
+    for (const email of esCache.esCache.values()) {
+      addEmailToSearchIndex(email, searchIndex);
+    }
+    searchIndex.isReady = true;
+    return searchIndex;
+  } catch (error) {
+    throw new Error("Failed build an email search index from the cache", { cause: error });
+  }
+};
+var searchEmails = async (query, esCache, searchIndex, options = {}) => {
+  try {
+    if (!searchIndex.isReady || !query.trim()) {
+      return [];
+    }
+    const {
+      fields = ["subject", "body", "from", "to"],
+      limit = 50,
+      boost = { subject: 3, body: 1, from: 2, to: 2 }
+    } = options;
+    const results = /* @__PURE__ */ new Map();
+    const searchPromises = fields.map(async (field) => {
+      let fieldResults;
+      switch (field) {
+        case "subject":
+          fieldResults = await searchIndex.subjectIndex.searchAsync(query);
+          break;
+        case "body":
+          fieldResults = await searchIndex.bodyIndex.searchAsync(query);
+          break;
+        case "from":
+          fieldResults = await searchIndex.fromIndex.searchAsync(query);
+          break;
+        case "to":
+          fieldResults = await searchIndex.toIndex.searchAsync(query);
+          break;
+        default:
+          return;
+      }
+      const fieldBoost = boost[field] || 1;
+      fieldResults.forEach((emailId) => {
+        const currentScore = results.get(String(emailId)) || 0;
+        results.set(String(emailId), currentScore + fieldBoost);
+      });
+    });
+    await Promise.all(searchPromises);
+    const emailResults = [];
+    for (const [emailId, score] of results) {
+      const email = esCache.esCache.get(emailId);
+      if (email) {
+        emailResults.push({ email, score });
+      }
+    }
+    emailResults.sort((a, b) => (b.score || 0) - (a.score || 0));
+    return emailResults.slice(0, limit);
+  } catch (error) {
+    throw new Error("Email search failed", { cause: error });
+  }
+};
+
+exports.addEmailToCache = addEmailToCache;
+exports.addEmailToSearchIndex = addEmailToSearchIndex;
+exports.addEmailsToCache = addEmailsToCache;
+exports.buildSearchIndexFromCache = buildSearchIndexFromCache;
+exports.closeDatabase = closeDatabase;
+exports.createCacheFromDB = createCacheFromDB;
+exports.deleteDatabase = deleteDatabase;
+exports.deleteEmail = deleteEmail;
+exports.deleteEmailFromCache = deleteEmailFromCache;
+exports.deleteOldestEmails = deleteOldestEmails;
+exports.deriveIndexKey = deriveIndexKey;
+exports.encryptAndStoreEmail = encryptAndStoreEmail;
+exports.encryptAndStoreManyEmail = encryptAndStoreManyEmail;
+exports.enforceMaxEmailNumber = enforceMaxEmailNumber;
+exports.getAllEmailsSortedNewestFirst = getAllEmailsSortedNewestFirst;
+exports.getAllEmailsSortedOldestFirst = getAllEmailsSortedOldestFirst;
+exports.getAndDecryptAllEmails = getAndDecryptAllEmails;
+exports.getAndDecryptEmail = getAndDecryptEmail;
+exports.getEmailBatch = getEmailBatch;
+exports.getEmailCount = getEmailCount;
+exports.getEmailFromCache = getEmailFromCache;
+exports.openDatabase = openDatabase;
+exports.removeEmailFromSearchIndex = removeEmailFromSearchIndex;
+exports.searchEmails = searchEmails;
+//# sourceMappingURL=email-search.js.map
+//# sourceMappingURL=email-search.js.map