internxt-crypto 0.0.14 → 1.0.0

package/dist/search-DUTm4-rN.js

@@ -0,0 +1,731 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_genID = require('./genID-cWOPmspk.js');
+const require_deriveKeysFromKey = require('./deriveKeysFromKey-C4McqO6_.js');
+const require_core = require('./core-Bj26rNdA.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 key for protecting database
+*/
+const deriveIndexKey = async (baseKey) => {
+	return require_deriveKeysFromKey.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 encryptedEmail = {
+			encEmailBody: await require_core.encryptEmailBodyWithKey(newEmailToStore.body, indexKey),
+			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) => {
+			return {
+				encEmailBody: await require_core.encryptEmailBodyWithKey(email.body, indexKey),
+				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_core.decryptEmailBody(encryptedEmail.encEmailBody, indexKey),
+			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_core.decryptEmailBody(encEmail.encEmailBody, indexKey),
+				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/utils.ts
+/**
+* Converts an Email type into a Uint8Array array.
+*
+* @param email - The email.
+* @returns The Uint8Array array representation of the Email type.
+*/
+function emailToBinary(email) {
+	try {
+		return require_genID.UTF8ToUint8(JSON.stringify(email));
+	} catch (error) {
+		throw new Error("Failed to convert EmailBody to Uint8Array", { 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 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;
+		searchIndex.subjectIndex.add(emailId, email.body.subject);
+		searchIndex.bodyIndex.add(emailId, email.body.text);
+		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
+Object.defineProperty(exports, 'addEmailToCache', {
+  enumerable: true,
+  get: function () {
+    return addEmailToCache;
+  }
+});
+Object.defineProperty(exports, 'addEmailToSearchIndex', {
+  enumerable: true,
+  get: function () {
+    return addEmailToSearchIndex;
+  }
+});
+Object.defineProperty(exports, 'addEmailsToCache', {
+  enumerable: true,
+  get: function () {
+    return addEmailsToCache;
+  }
+});
+Object.defineProperty(exports, 'buildSearchIndexFromCache', {
+  enumerable: true,
+  get: function () {
+    return buildSearchIndexFromCache;
+  }
+});
+Object.defineProperty(exports, 'closeDatabase', {
+  enumerable: true,
+  get: function () {
+    return closeDatabase;
+  }
+});
+Object.defineProperty(exports, 'createCacheFromDB', {
+  enumerable: true,
+  get: function () {
+    return createCacheFromDB;
+  }
+});
+Object.defineProperty(exports, 'deleteDatabase', {
+  enumerable: true,
+  get: function () {
+    return deleteDatabase;
+  }
+});
+Object.defineProperty(exports, 'deleteEmail', {
+  enumerable: true,
+  get: function () {
+    return deleteEmail;
+  }
+});
+Object.defineProperty(exports, 'deleteEmailFromCache', {
+  enumerable: true,
+  get: function () {
+    return deleteEmailFromCache;
+  }
+});
+Object.defineProperty(exports, 'deleteOldestEmails', {
+  enumerable: true,
+  get: function () {
+    return deleteOldestEmails;
+  }
+});
+Object.defineProperty(exports, 'deriveIndexKey', {
+  enumerable: true,
+  get: function () {
+    return deriveIndexKey;
+  }
+});
+Object.defineProperty(exports, 'encryptAndStoreEmail', {
+  enumerable: true,
+  get: function () {
+    return encryptAndStoreEmail;
+  }
+});
+Object.defineProperty(exports, 'encryptAndStoreManyEmail', {
+  enumerable: true,
+  get: function () {
+    return encryptAndStoreManyEmail;
+  }
+});
+Object.defineProperty(exports, 'enforceMaxEmailNumber', {
+  enumerable: true,
+  get: function () {
+    return enforceMaxEmailNumber;
+  }
+});
+Object.defineProperty(exports, 'getAllEmailsSortedNewestFirst', {
+  enumerable: true,
+  get: function () {
+    return getAllEmailsSortedNewestFirst;
+  }
+});
+Object.defineProperty(exports, 'getAllEmailsSortedOldestFirst', {
+  enumerable: true,
+  get: function () {
+    return getAllEmailsSortedOldestFirst;
+  }
+});
+Object.defineProperty(exports, 'getAndDecryptAllEmails', {
+  enumerable: true,
+  get: function () {
+    return getAndDecryptAllEmails;
+  }
+});
+Object.defineProperty(exports, 'getAndDecryptEmail', {
+  enumerable: true,
+  get: function () {
+    return getAndDecryptEmail;
+  }
+});
+Object.defineProperty(exports, 'getEmailBatch', {
+  enumerable: true,
+  get: function () {
+    return getEmailBatch;
+  }
+});
+Object.defineProperty(exports, 'getEmailCount', {
+  enumerable: true,
+  get: function () {
+    return getEmailCount;
+  }
+});
+Object.defineProperty(exports, 'getEmailFromCache', {
+  enumerable: true,
+  get: function () {
+    return getEmailFromCache;
+  }
+});
+Object.defineProperty(exports, 'openDatabase', {
+  enumerable: true,
+  get: function () {
+    return openDatabase;
+  }
+});
+Object.defineProperty(exports, 'removeEmailFromSearchIndex', {
+  enumerable: true,
+  get: function () {
+    return removeEmailFromSearchIndex;
+  }
+});
+Object.defineProperty(exports, 'searchEmails', {
+  enumerable: true,
+  get: function () {
+    return searchEmails;
+  }
+});
+//# sourceMappingURL=search-DUTm4-rN.js.map