internxt-crypto 0.0.14 → 1.0.1

package/dist/email-search.js

@@ -1,599 +1,27 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
-const require_emailKeys = require('./emailKeys-C0KhtfNP.js');
-let idb = require("idb");
-let flexsearch = require("flexsearch");
+const require_search = require('./search-DUTm4-rN.js');
 
-//#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 key for protecting database
-*/
-const deriveIndexKey = async (baseKey) => {
-	return require_deriveKeysFromPassword.deriveSymmetricKeyFromContext(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 key for protecting database
-* @param esDB - The database
-*/
-const encryptAndStoreEmail = async (newEmailToStore, indexKey, esDB) => {
-	try {
-		const aux = require_emailKeys.getAux(newEmailToStore.params, false);
-		const encryptedEmail = {
-			enc: await require_emailKeys.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 key 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_emailKeys.getAux(email.params, false);
-			return {
-				enc: await require_emailKeys.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 key key for protecting database
-* @param encryptedEmail - The encrypted email
-* @returns The decrypted email
-*/
-const decryptEmail = async (indexKey, encryptedEmail) => {
-	try {
-		return {
-			body: await require_emailKeys.decryptEmailSymmetrically(indexKey, require_emailKeys.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 key 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 key 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_emailKeys.decryptEmailSymmetrically(indexKey, require_emailKeys.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 key 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 Uint8Array 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 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 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_emailKeys.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 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}`, { cause: 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
-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
+exports.addEmailToCache = require_search.addEmailToCache;
+exports.addEmailToSearchIndex = require_search.addEmailToSearchIndex;
+exports.addEmailsToCache = require_search.addEmailsToCache;
+exports.buildSearchIndexFromCache = require_search.buildSearchIndexFromCache;
+exports.closeDatabase = require_search.closeDatabase;
+exports.createCacheFromDB = require_search.createCacheFromDB;
+exports.deleteDatabase = require_search.deleteDatabase;
+exports.deleteEmail = require_search.deleteEmail;
+exports.deleteEmailFromCache = require_search.deleteEmailFromCache;
+exports.deleteOldestEmails = require_search.deleteOldestEmails;
+exports.deriveIndexKey = require_search.deriveIndexKey;
+exports.encryptAndStoreEmail = require_search.encryptAndStoreEmail;
+exports.encryptAndStoreManyEmail = require_search.encryptAndStoreManyEmail;
+exports.enforceMaxEmailNumber = require_search.enforceMaxEmailNumber;
+exports.getAllEmailsSortedNewestFirst = require_search.getAllEmailsSortedNewestFirst;
+exports.getAllEmailsSortedOldestFirst = require_search.getAllEmailsSortedOldestFirst;
+exports.getAndDecryptAllEmails = require_search.getAndDecryptAllEmails;
+exports.getAndDecryptEmail = require_search.getAndDecryptEmail;
+exports.getEmailBatch = require_search.getEmailBatch;
+exports.getEmailCount = require_search.getEmailCount;
+exports.getEmailFromCache = require_search.getEmailFromCache;
+exports.openDatabase = require_search.openDatabase;
+exports.removeEmailFromSearchIndex = require_search.removeEmailFromSearchIndex;
+exports.searchEmails = require_search.searchEmails;