internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/email-search.js

@@ -0,0 +1,637 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_constants = require('./constants-Ccp21E03.js');
+require('./utils-CNs3cyDj.js');
+require('./hash-BoqwNkcd.js');
+require('./symmetric-crypto-D65zB396.js');
+const require_derive_key = require('./derive-key-CBf2WxJd.js');
+require('./post-quantum-crypto-CAi-cEkV.js');
+const require_email_crypto = require('./email-crypto-BrT98taw.js');
+let idb = require("idb");
+let flexsearch = require("flexsearch");
+
+//#region src/email-search/indexedDB.ts
+/**
+* Returns IndexedDB database name for the given user
+*
+* @param userID - The user ID
+* @returns The database name
+*/
+const getDatabaseName = (userID) => {
+	return `ES:${userID}:DB`;
+};
+/**
+* Opens IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const openDatabase = async (userID) => {
+	try {
+		return (0, idb.openDB)(getDatabaseName(userID), require_constants.DB_VERSION, { upgrade(db) {
+			if (!db.objectStoreNames.contains(require_constants.DB_LABEL)) db.createObjectStore(require_constants.DB_LABEL, { keyPath: "id" }).createIndex("byTime", "params.createdAt");
+		} });
+	} catch (error) {
+		throw new Error(`Cannot open a database for the user ${userID}`, { cause: error });
+	}
+};
+/**
+* Closes the IndexedDB database
+*
+* @param esDB - The database
+*/
+const closeDatabase = (esDB) => {
+	return esDB.close();
+};
+/**
+* Deletes IndexedDB database for the given user
+*
+* @param userID - The user ID
+* @returns The database
+*/
+const deleteDatabase = async (userID) => {
+	return (0, idb.deleteDB)(getDatabaseName(userID));
+};
+/**
+* Derives database encryption key for the given user
+*
+* @param userID - The user ID
+* @returns The symmetric CryptoKey for protecting database
+*/
+const deriveIndexKey = async (baseKey) => {
+	return require_derive_key.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_INDEX, baseKey);
+};
+/**
+* Encrypts the given email and stores it in the IndexedDB database
+*
+* @param newEmailToStore - The email for storing
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esDB - The database
+*/
+const encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
+	try {
+		const aux = require_email_crypto.getAux(newEmailToStore.params, false);
+		const encryptedEmail = {
+			enc: await require_email_crypto.encryptEmailContentSymmetricallyWithKey(newEmailToStore.body, indexKey, aux, newEmailToStore.id),
+			params: newEmailToStore.params,
+			id: newEmailToStore.id
+		};
+		await esDB.put(require_constants.DB_LABEL, encryptedEmail);
+	} catch (error) {
+		throw new Error("Cannot encrypt and add the given email to the database", { cause: error });
+	}
+};
+/**
+* Encrypts the given set of emails and stores it in the IndexedDB database
+*
+* @param newEmailsToStore - The set of emails for storing
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esDB - The database
+*/
+const encryptAndStoreManyEmail = async (newEmailsToStore, indexKey, esDB) => {
+	try {
+		const encryptedEmails = await Promise.all(newEmailsToStore.map(async (email) => {
+			const aux = require_email_crypto.getAux(email.params, false);
+			return {
+				enc: await require_email_crypto.encryptEmailContentSymmetricallyWithKey(email.body, indexKey, aux, email.id),
+				params: email.params,
+				id: email.id
+			};
+		}));
+		const tr = esDB.transaction(require_constants.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 });
+	}
+};
+/**
+* Decrypts the given email
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param encryptedEmail - The encrypted email
+* @returns The decrypted email
+*/
+const decryptEmail = async (indexKey, encryptedEmail) => {
+	try {
+		return {
+			body: await require_email_crypto.decryptEmailSymmetrically(indexKey, require_email_crypto.getAux(encryptedEmail.params, false), encryptedEmail.enc),
+			params: encryptedEmail.params,
+			id: encryptedEmail.id
+		};
+	} catch (error) {
+		throw new Error("Cannot decrypt the given email", { cause: error });
+	}
+};
+/**
+* Fetches the email from the database and decrypts it
+*
+* @param emailID - The email identifier
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param encryptedEmail - The encrypted email
+* @returns The decrypted email
+*/
+const getAndDecryptEmail = async (emailID, indexKey, esDB) => {
+	try {
+		const encryptedEmail = await esDB.get(require_constants.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 });
+	}
+};
+/**
+* Fetches all email from the database and decrypts them
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esDB - The database
+* @returns The decrypted emails
+*/
+const getAndDecryptAllEmails = async (indexKey, esDB) => {
+	try {
+		const encryptedEmails = await esDB.getAll(require_constants.DB_LABEL);
+		return (await Promise.all(encryptedEmails.map(async (encEmail) => {
+			return {
+				body: await require_email_crypto.decryptEmailSymmetrically(indexKey, require_email_crypto.getAux(encEmail.params, false), encEmail.enc),
+				params: encEmail.params,
+				id: encEmail.id
+			};
+		}))).filter((email) => email !== null);
+	} catch (error) {
+		throw new Error("Cannot fetch and decrypt all emails from the database", { cause: error });
+	}
+};
+/**
+* Deletes the email from the database
+*
+* @param emailID - The email identifier
+* @param esDB - The database
+*/
+const deleteEmail = async (emailID, esDB) => {
+	await esDB.delete(require_constants.DB_LABEL, emailID);
+};
+/**
+* Returns the number of stored email
+*
+* @param esDB - The database
+* @returns The number of stored emails
+*/
+const getEmailCount = async (esDB) => {
+	return await esDB.count(require_constants.DB_LABEL);
+};
+/**
+* Removes the given number of oldests emails from the database
+*
+* @param emailsToDelete - The number of emails to delete
+* @param esDB - The database
+*/
+const deleteOldestEmails = async (emailsToDelete, esDB) => {
+	try {
+		const tx = esDB.transaction(require_constants.DB_LABEL, "readwrite");
+		let cursor = await tx.store.index("byTime").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 });
+	}
+};
+/**
+* Enforces the maximum email number in the database
+*
+* @param esDB - The database
+* @param max - The maximum allowed number of emails
+*/
+const 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 });
+	}
+};
+/**
+* Fetches all emails from the database, decrypts them and sortes the results in the specified order
+*
+* @param esDB - The database
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param direction - The order of sorting. If 'next' - oldest first, if 'prev' - newest first
+* @returns Decryped emails in the specified order
+*/
+const fetchEmails = async (esDB, indexKey, direction) => {
+	try {
+		const index = esDB.transaction(require_constants.DB_LABEL, "readonly").store.index("byTime");
+		const encryptedEmails = [];
+		let cursor = await index.openCursor(null, direction);
+		while (cursor) {
+			encryptedEmails.push(cursor.value);
+			cursor = await cursor.continue();
+		}
+		return await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail)));
+	} catch (error) {
+		throw new Error("Cannot fetch emails from database", { cause: error });
+	}
+};
+/**
+* Fetches all emails from the database, decrypts them and sortes the results based on the creation time (newest first)
+*
+* @param esDB - The database
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @returns The number of stored emails
+*/
+const getAllEmailsSortedNewestFirst = async (esDB, indexKey) => {
+	return fetchEmails(esDB, indexKey, "prev");
+};
+/**
+* Fetches all emails from the database, decrypts them and sortes the results based on the creation time (oldest first)
+*
+* @param esDB - The database
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @returns The number of stored emails
+*/
+const getAllEmailsSortedOldestFirst = async (esDB, indexKey) => {
+	return fetchEmails(esDB, indexKey, "next");
+};
+/**
+* Fetches a batch of emails from the database, decrypts them and sortes the results based on the creation time (newest first)
+*
+* @param esDB - The database
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param batchSize - The size of the batch
+* @param startCursor - The starting point (optional). If not given, starts from the beginning
+* @returns The number of stored emails
+*/
+const getEmailBatch = async (esDB, indexKey, batchSize, startCursor) => {
+	try {
+		const index = esDB.transaction(require_constants.DB_LABEL, "readonly").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();
+		}
+		return {
+			emails: await Promise.all(encryptedEmails.map((encryptedEmail) => decryptEmail(indexKey, encryptedEmail))),
+			nextCursor: count === batchSize ? nextCursor : void 0
+		};
+	} catch (error) {
+		throw new Error(`Cannot fetch email batch of ${batchSize} from the database`, { cause: error });
+	}
+};
+
+//#endregion
+//#region src/email-search/mailCache.ts
+/**
+* Estimates the email size in the memory
+*
+* @param email - The email
+* @returns The estimation of the email size
+*/
+function sizeOfEmail(email) {
+	return require_email_crypto.emailToBinary(email).byteLength;
+}
+/**
+* Creates an empty cache variable
+*
+* @returns The empty cache
+*/
+function createEmptyCache() {
+	return {
+		esCache: /* @__PURE__ */ new Map(),
+		cacheSize: 0,
+		isCacheLimited: false,
+		isCacheReady: true
+	};
+}
+/**
+* Fetches all emails from the database in batches and cahces them
+*
+* @param indexKey - The symmetric CryptoKey key for protecting database
+* @param esCache - The cache to add emails too
+* @param esDB - The database
+*/
+const 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 <= require_constants.MAX_EMAIL_PER_BATCH) addEmailsToCache(await getAllEmailsSortedNewestFirst(esDB, indexKey), esCache);
+		else {
+			let nextCursor = void 0;
+			let cacheFull = false;
+			while (!cacheFull) {
+				const { emails, nextCursor: newCursor } = await getEmailBatch(esDB, indexKey, require_constants.MAX_EMAIL_PER_BATCH, nextCursor);
+				if (!newCursor || !emails.length) break;
+				nextCursor = newCursor;
+				if (!addEmailsToCache(emails, esCache)) cacheFull = true;
+			}
+		}
+		return esCache;
+	} catch (error) {
+		throw new Error(`Email caching failed: ${error}`);
+	}
+};
+/**
+* Gets an email from the cache
+*
+* @param emailID - The email identifier
+* @param esCache - The email cache
+* @returns The found email or throws an error
+*/
+const 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;
+};
+/**
+* Removes the email from cache
+*
+* @param emailID - The email identifier
+* @param esCache - The email cache
+*/
+const deleteEmailFromCache = async (emailID, esCache) => {
+	try {
+		const size = sizeOfEmail(await getEmailFromCache(emailID, esCache));
+		if (esCache.esCache.delete(emailID)) esCache.cacheSize -= size;
+	} catch (error) {
+		throw new Error(`Failed to delete email with ID ${emailID}`, { cause: error });
+	}
+};
+/**
+* Adds emails to the cache
+*
+* @param emails - The emails to add
+* @param esCache - The email cache
+* @returns TRUE if all emails were added sucessfully, or FALSE and error reason.
+*/
+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 });
+	}
+}
+/**
+* Adds email to the cache
+*
+* @param email - The email to add
+* @param esCache - The email cache
+* @returns TRUE if the email was added sucessfully, or FALSE and error reason.
+*/
+const 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 > require_constants.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 });
+	}
+};
+
+//#endregion
+//#region src/email-search/search.ts
+const SUBJECT_OPTIONS = {
+	preset: "match",
+	tokenize: "forward",
+	resolution: 9,
+	minlength: 2,
+	optimize: true,
+	fastupdate: true,
+	cache: true
+};
+const BODY_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	minlength: 3,
+	resolution: 6
+};
+const FROM_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
+};
+const TO_OPTIONS = {
+	...SUBJECT_OPTIONS,
+	tokenize: "strict",
+	minlength: 1
+};
+/**
+* Creates new email search index
+*
+* @returns The email search index
+*/
+const 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
+});
+/**
+* Adds the given email to the email search index
+*
+* @param email - The email to add
+* @param searchIndex - The email search index
+*/
+const 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 recipientsText = (email.params.recipients?.length ? email.params.recipients : [email.params.recipient]).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 });
+	}
+};
+/**
+* Removes the email from the email search index
+*
+* @param emailID - The email identifier
+* @param searchIndex - The email search index
+*/
+const 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 });
+	}
+};
+/**
+* Buils the email search index from the email cache
+*
+* @param esCache - The email cache
+* @returns  The email search index
+*/
+const 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 });
+	}
+};
+/**
+* Searches in teh
+*
+* @param query - The string to search for
+* @param esCache - The email cache
+* @param searchIndex - The email search index
+* @param opetions - The optional search limitations
+* @returns The result of the email search (emails ans their corresponding result weights)
+*/
+const 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 });
+	}
+};
+
+//#endregion
+//#region src/email-search/index.ts
+var email_search_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	addEmailToCache: () => addEmailToCache,
+	addEmailToSearchIndex: () => addEmailToSearchIndex,
+	addEmailsToCache: () => addEmailsToCache,
+	buildSearchIndexFromCache: () => buildSearchIndexFromCache,
+	closeDatabase: () => closeDatabase,
+	createCacheFromDB: () => createCacheFromDB,
+	deleteDatabase: () => deleteDatabase,
+	deleteEmail: () => deleteEmail,
+	deleteEmailFromCache: () => deleteEmailFromCache,
+	deleteOldestEmails: () => deleteOldestEmails,
+	deriveIndexKey: () => deriveIndexKey,
+	encryptAndStoreEmail: () => encryptAndStoreEmail,
+	encryptAndStoreManyEmail: () => encryptAndStoreManyEmail,
+	enforceMaxEmailNumber: () => enforceMaxEmailNumber,
+	getAllEmailsSortedNewestFirst: () => getAllEmailsSortedNewestFirst,
+	getAllEmailsSortedOldestFirst: () => getAllEmailsSortedOldestFirst,
+	getAndDecryptAllEmails: () => getAndDecryptAllEmails,
+	getAndDecryptEmail: () => getAndDecryptEmail,
+	getEmailBatch: () => getEmailBatch,
+	getEmailCount: () => getEmailCount,
+	getEmailFromCache: () => getEmailFromCache,
+	openDatabase: () => openDatabase,
+	removeEmailFromSearchIndex: () => removeEmailFromSearchIndex,
+	searchEmails: () => searchEmails
+});
+
+//#endregion
+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;
+Object.defineProperty(exports, 'email_search_exports', {
+  enumerable: true,
+  get: function () {
+    return email_search_exports;
+  }
+});
+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