core-3nweb-client-lib 0.49.6 → 0.49.8

package/build/core/asmail/inbox/index.js

@@ -16,8 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InboxOnServer = void 0;
-const error_1 = require("../../../lib-common/exceptions/error");
+exports.makeInboxOnServer = makeInboxOnServer;
 const synced_1 = require("../../../lib-common/processes/synced");
 const recipient_1 = require("../../../lib-client/asmail/recipient");
 const opener_1 = require("../msg/opener");
@@ -32,197 +31,161 @@ const cached_msgs_1 = require("./cached-msgs");
 const timed_cache_1 = require("../../../lib-common/timed-cache");
 const fs_sync_utils_1 = require("../../../lib-client/fs-utils/fs-sync-utils");
 const MSG_INDEX_FOLDER = 'msg-index';
-/**
- * Instance of this class represents inbox-on-mail-server.
- * It uses api to manage messages on a ASMail server, caching and recording
- * some information to allow faster response, and to keep message keys, while
- * messages have not been removed via direct action or due to expiry.
- * This object is also responsible for expiring messages on the server.
- */
-class InboxOnServer {
-    constructor(r, msgReceiver, storages, cryptor, random, downloader, cache, index, logError) {
-        this.r = r;
-        this.msgReceiver = msgReceiver;
-        this.storages = storages;
-        this.cryptor = cryptor;
-        this.random = random;
-        this.downloader = downloader;
-        this.cache = cache;
-        this.index = index;
-        this.logError = logError;
-        this.procs = new synced_1.NamedProcs();
-        this.recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
-        this.inboxEvents = new inbox_events_1.InboxEvents(this.msgReceiver, this.getMsg.bind(this), this.listNewMsgs.bind(this), this.removeMsg.bind(this), this.logError);
-        Object.seal(this);
+async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
+    const procs = new synced_1.NamedProcs();
+    const recentlyOpenedMsgs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
+    const { getStorages, cryptor, random, logError, } = r;
+    (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
+    const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, MSG_INDEX_FOLDER);
+    const indexLocalFS = await localFS.writableSubRoot(MSG_INDEX_FOLDER);
+    const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
+    const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
+    const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
+    const index = await (0, msg_indexing_1.makeMsgIndex)(indexSyncedFS, indexLocalFS, r.logError);
+    const inboxEvents = new inbox_events_1.InboxEvents(msgReceiver, getMsg, listNewMsgs, removeMsg, r.logError);
+    async function close() {
+        index.stopSyncing();
+        inboxEvents.close();
     }
-    static async makeAndStart(cachePath, syncedFS, r) {
-        try {
-            (0, file_1.ensureCorrectFS)(syncedFS, 'synced', true);
-            const msgReceiver = new recipient_1.MailRecipient(r.address, r.getSigner, () => r.asmailResolver(r.address), r.makeNet());
-            const downloader = new msg_downloader_1.MsgDownloader(msgReceiver);
-            const cache = await cached_msgs_1.CachedMessages.makeFor(cachePath, downloader, r.logError);
-            const indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeAndUploadFolderIn)(syncedFS, MSG_INDEX_FOLDER);
-            const index = await msg_indexing_1.MsgIndex.make(indexSyncedFS);
-            await (0, fs_sync_utils_1.uploadFolderChangesIfAny)(syncedFS);
-            const inbox = new InboxOnServer(r.correspondents, msgReceiver, r.getStorages, r.cryptor, r.random, downloader, cache, index, r.logError);
-            return inbox;
-        }
-        catch (err) {
-            throw (0, error_1.errWithCause)(err, 'Failed to initialize Inbox');
-        }
-    }
-    async close() {
-        this.index.stopSyncing();
-        this.inboxEvents.close();
-    }
-    makeCAP() {
+    function makeCAP() {
         const service = {
-            getMsg: this.getMsg.bind(this),
-            listMsgs: this.listMsgs.bind(this),
-            removeMsg: this.removeMsg.bind(this),
-            subscribe: this.inboxEvents.subscribe.bind(this.inboxEvents)
+            getMsg,
+            listMsgs,
+            removeMsg,
+            subscribe: inboxEvents.subscribe.bind(inboxEvents)
         };
         return Object.freeze(service);
     }
-    async removeMsg(msgId) {
+    async function removeMsg(msgId) {
         // check for an already started process
         const procId = 'removal of ' + msgId;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
+        const promise = procs.latestTaskAtThisMoment(procId);
         if (promise) {
             return promise;
         }
         // start removal process
-        return this.procs.start(procId, (async () => {
+        return procs.start(procId, (async () => {
             await Promise.all([
-                this.index.remove(msgId),
-                this.removeMsgFromServerAndCache(msgId)
+                index.remove(msgId),
+                removeMsgFromServerAndCache(msgId)
             ]);
         }));
     }
-    async removeMsgFromServerAndCache(msgId) {
+    async function removeMsgFromServerAndCache(msgId) {
         await Promise.all([
-            this.cache.deleteMsg(msgId),
+            cache.deleteMsg(msgId),
             // XXX the following is suspicious, as it swallows other exceptions too
-            this.msgReceiver.removeMsg(msgId).catch(() => { })
+            msgReceiver.removeMsg(msgId).catch(() => { })
         ]);
     }
-    async msgFromDiskOrDownload(msgId) {
-        const msgOnDisk = await this.cache.findMsg(msgId);
+    async function msgFromDiskOrDownload(msgId) {
+        const msgOnDisk = await cache.findMsg(msgId);
         if (msgOnDisk) {
             return msgOnDisk;
         }
-        const meta = await this.downloader.getMsgMeta(msgId);
-        return await this.cache.addMsg(msgId, meta);
+        const meta = await downloader.getMsgMeta(msgId);
+        return await cache.addMsg(msgId, meta);
     }
-    async startCachingAndAddKeyToIndex(msgId) {
-        const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
+    function checkerOfMidKeyCerts(deliveryTS) {
+        return (certs) => (0, key_verification_1.checkAndExtractPKeyWithAddress)(msgReceiver.getNet(), r.correspondents.midResolver, certs, Math.round(deliveryTS / 1000));
+    }
+    function msgReadingAndOpening(msgId, mainObjId, msgOnDisk) {
+        // lazy main obj source
+        let mainObjSrc = undefined;
+        async function getMainObjHeader() {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return mainObjSrc.readHeader();
+        }
+        async function getOpenedMsg(mainObjFileKey, msgKeyPackLen) {
+            if (!mainObjSrc) {
+                mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
+            }
+            return await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, cryptor);
+        }
+        return {
+            getMainObjHeader, getOpenedMsg
+        };
+    }
+    async function startCachingAndAddKeyToIndex(msgId) {
+        const msgOnDisk = await msgFromDiskOrDownload(msgId);
         const meta = await msgOnDisk.getMsgMeta();
+        const { getMainObjHeader, getOpenedMsg } = msgReadingAndOpening(msgId, meta.extMeta.objIds[0], msgOnDisk);
         try {
-            // setup closures, some memoized, for use by keyring
-            let mainObjSrc = undefined;
-            const mainObjId = meta.extMeta.objIds[0];
-            const getMainObjHeader = async () => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                return mainObjSrc.readHeader();
-            };
-            const getOpenedMsg = async (mainObjFileKey, msgKeyPackLen) => {
-                if (!mainObjSrc) {
-                    mainObjSrc = await msgOnDisk.getMsgObj(mainObjId);
-                }
-                const openedMsg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObjSrc, msgKeyPackLen, mainObjFileKey, this.cryptor);
-                return openedMsg;
-            };
-            const checkMidKeyCerts = (certs) => {
-                return (0, key_verification_1.checkAndExtractPKeyWithAddress)(this.msgReceiver.getNet(), this.r.midResolver, certs, Math.round(msgOnDisk.deliveryTS / 1000));
-            };
-            const decrOut = await this.r.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkMidKeyCerts);
+            const decrOut = await r.correspondents.msgDecryptor(meta.extMeta, getMainObjHeader, getOpenedMsg, checkerOfMidKeyCerts(msgOnDisk.deliveryTS));
             if (decrOut) {
                 const { decrInfo, openedMsg } = decrOut;
                 openedMsg.setMsgKeyRole(decrInfo.keyStatus);
-                this.checkServerAuthIfPresent(meta, decrInfo);
+                // XXX we have never used this part of protocol, should it be removed at all from ASMail protocol?
+                checkServerAuthIfPresent(meta, decrInfo);
                 // add records cache and to index
-                this.recentlyOpenedMsgs.set(msgId, openedMsg);
+                recentlyOpenedMsgs.set(msgId, openedMsg);
                 const msgInfo = {
                     msgType: openedMsg.getSection('Msg Type'),
                     msgId,
                     deliveryTS: msgOnDisk.deliveryTS
                 };
-                await this.index.add(msgInfo, decrInfo);
+                await index.add(msgInfo, decrInfo);
                 await Promise.all([
-                    this.absorbSendingParams(openedMsg),
-                    this.markOwnParams(meta, openedMsg.sender)
+                    absorbSendingParams(openedMsg),
+                    markOwnParams(meta, openedMsg.sender)
                 ]);
             }
             else {
                 // check, if msg has already been indexed
-                const knownDecr = await this.index.getKeyFor(msgId, msgOnDisk.deliveryTS);
+                const knownDecr = await index.getKeyFor(msgId, msgOnDisk.deliveryTS);
                 if (!knownDecr) {
-                    await msgOnDisk.updateMsgKeyStatus('not-found');
                     return false;
                 }
-                // TODO try to open main message, just as a check
             }
-            await msgOnDisk.updateMsgKeyStatus('ok');
             return true;
         }
         catch (exc) {
-            await this.logError(exc, `Problem with opening message ${msgId}`);
-            if (msgOnDisk.keyStatus !== 'ok') {
-                await msgOnDisk.updateMsgKeyStatus('fail');
-            }
+            await logError(exc, `Problem with opening message ${msgId}`);
             return false;
         }
     }
-    async markOwnParams(meta, sender) {
+    async function markOwnParams(meta, sender) {
         if (!meta.invite) {
             return;
         }
-        await this.r.markOwnSendingParamsAsUsed(sender, meta.invite);
+        await r.correspondents.markOwnSendingParamsAsUsed(sender, meta.invite);
     }
-    async absorbSendingParams(openedMsg) {
+    async function absorbSendingParams(openedMsg) {
         const sendingParams = openedMsg.nextSendingParams;
         if (!sendingParams) {
             return;
         }
         const address = openedMsg.sender;
-        await this.r.saveParamsForSendingTo(address, sendingParams);
+        await r.correspondents.saveParamsForSendingTo(address, sendingParams);
     }
-    checkServerAuthIfPresent(meta, decrInfo) {
-        // if sender authenticated to server, check that it matches address,
-        // recovered from message decryption 
-        if (meta.authSender
-            && !(0, canonical_address_1.areAddressesEqual)(meta.authSender, decrInfo.correspondent)) {
-            throw new Error(`Sender authenticated to server as ${meta.authSender}, while decrypting key is associated with ${decrInfo.correspondent}`);
+    function debouncingProc(procId, action) {
+        const promise = procs.latestTaskAtThisMoment(procId);
+        if (promise) {
+            return promise;
         }
+        return procs.start(procId, action);
     }
-    async listMsgs(fromTS) {
+    async function listMsgs(fromTS) {
         const checkServer = true; // XXX in future this will be an option from req
         if (!checkServer) {
-            return this.index.listMsgs(fromTS);
-        }
-        // check for an already started process
-        const procId = 'listing msgs';
-        const promise = this.procs.latestTaskAtThisMoment(procId);
-        if (promise) {
-            return promise;
+            return index.listMsgs(fromTS);
         }
-        // start message listing process
-        return this.procs.start(procId, async () => {
+        return debouncingProc('listing msgs', async () => {
             // message listing info is located in index, yet, process involves
             // getting and caching messages' metadata
             let msgIds;
             try {
-                msgIds = await this.msgReceiver.listMsgs(fromTS);
+                msgIds = await msgReceiver.listMsgs(fromTS);
             }
             catch (exc) {
                 if (exc.type !== 'connect') {
                     throw exc;
                 }
-                return this.index.listMsgs(fromTS);
+                return index.listMsgs(fromTS);
             }
-            const indexedMsgs = await this.index.listMsgs(fromTS);
+            const indexedMsgs = await index.listMsgs(fromTS);
             for (const info of indexedMsgs) {
                 const ind = msgIds.indexOf(info.msgId);
                 if (ind >= 0) {
@@ -232,17 +195,17 @@ class InboxOnServer {
             if (msgIds.length === 0) {
                 return indexedMsgs;
             }
-            await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)
+            await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)
                 .catch(async (exc) => {
-                await this.logError(exc, `Failed to start caching message ${msgId}`);
+                await logError(exc, `Failed to start caching message ${msgId}`);
             })));
-            return this.index.listMsgs(fromTS);
+            return index.listMsgs(fromTS);
         });
     }
-    async listNewMsgs(fromTS) {
-        const msgIds = await this.msgReceiver.listMsgs(fromTS);
+    async function listNewMsgs(fromTS) {
+        const msgIds = await msgReceiver.listMsgs(fromTS);
         // remove from listing messages already in index
-        const indexedMsgs = await this.index.listMsgs(fromTS);
+        const indexedMsgs = await index.listMsgs(fromTS);
         for (const info of indexedMsgs) {
             const ind = msgIds.indexOf(info.msgId);
             if (ind >= 0) {
@@ -253,54 +216,39 @@ class InboxOnServer {
             return [];
         }
         // cache and index these
-        await Promise.all(msgIds.map(msgId => this.startCachingAndAddKeyToIndex(msgId)));
+        await Promise.all(msgIds.map(msgId => startCachingAndAddKeyToIndex(msgId)));
         // get info's from index, focusing on specific messages only
-        return (await this.index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
+        return (await index.listMsgs(fromTS)).filter(({ msgId }) => msgIds.includes(msgId));
     }
-    async getMsg(msgId) {
+    async function getMsg(msgId) {
         if (!msgId || (typeof msgId !== 'string')) {
             throw `Given message id is not a non-empty string`;
         }
-        const procId = `get msg #${msgId}`;
-        const promise = this.procs.latestTaskAtThisMoment(procId);
-        if (promise) {
-            return promise;
-        }
-        return this.procs.start(procId, async () => {
-            const msgOnDisk = await this.msgFromDiskOrDownload(msgId);
-            let msg = this.recentlyOpenedMsgs.get(msgId);
+        return debouncingProc(`get msg #${msgId}`, async () => {
+            const msgOnDisk = await msgFromDiskOrDownload(msgId);
+            let msg = recentlyOpenedMsgs.get(msgId);
             if (msg) {
-                return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
-            }
-            if ((msgOnDisk.keyStatus === 'not-found') ||
-                (msgOnDisk.keyStatus === 'fail')) {
-                // XXX 
-                // message cannot be opened, and should be removed
-                // await Promise.all([
-                // 	this.index.remove(msgInfo),
-                // 	this.removeMsgFromServerAndCache(msgId)
-                // ]);
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
-            }
-            else if (msgOnDisk.keyStatus === 'not-checked') {
-                await this.startCachingAndAddKeyToIndex(msgId);
-            }
-            else if (msgOnDisk.keyStatus !== 'ok') {
-                throw new Error(`Unknown message key status ${msgOnDisk.keyStatus}`);
+                return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
             }
             const meta = await msgOnDisk.getMsgMeta();
             const mainObjId = meta.extMeta.objIds[0];
             const mainObj = await msgOnDisk.getMsgObj(mainObjId);
-            const msgKey = await this.index.getKeyFor(msgId, meta.deliveryCompletion);
+            let msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
             if (!msgKey) {
-                throw (0, recipient_1.makeMsgNotFoundException)(msgId);
+                if (!(await startCachingAndAddKeyToIndex(msgId))) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
+                msgKey = await index.getKeyFor(msgId, meta.deliveryCompletion);
+                if (!msgKey) {
+                    throw (0, recipient_1.makeFailToDecryptMsgException)(msgId);
+                }
             }
-            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, this.cryptor);
+            msg = await (0, opener_1.openMsg)(msgId, mainObjId, mainObj, msgKey.mainObjHeaderOfs, msgKey.msgKey, cryptor);
             msg.setMsgKeyRole(msgKey.msgKeyRole);
-            return this.msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
+            return msgToUIForm(msg, msgOnDisk.deliveryTS, msgOnDisk);
         });
     }
-    msgToUIForm(msg, deliveryTS, msgOnDisk) {
+    function msgToUIForm(msg, deliveryTS, msgOnDisk) {
         const m = {
             sender: msg.sender,
             establishedSenderKeyChain: msg.establishedKeyChain,
@@ -325,21 +273,23 @@ class InboxOnServer {
         }
         const attachments = msg.attachmentsJSON;
         if (attachments) {
-            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, this.storages, this.cryptor, this.random, this.logError);
+            m.attachments = (0, fs_1.fsForAttachments)(msgOnDisk, attachments, getStorages, cryptor, random, logError);
         }
         return m;
     }
-    suspendNetworkActivity() {
-        this.inboxEvents.suspendNetworkActivity();
-    }
-    resumeNetworkActivity() {
-        this.inboxEvents.resumeNetworkActivity();
-    }
-    get connectivityEvent$() {
-        return this.inboxEvents.connectionEvent$;
+    return {
+        connectivityEvent$: inboxEvents.connectionEvent$,
+        resumeNetworkActivity: inboxEvents.resumeNetworkActivity.bind(inboxEvents),
+        suspendNetworkActivity: inboxEvents.suspendNetworkActivity.bind(inboxEvents),
+        close,
+        makeCAP
+    };
+}
+function checkServerAuthIfPresent(meta, { correspondent }) {
+    // if sender authenticated to server, check that it matches address,
+    // recovered from message decryption 
+    if (meta.authSender && !(0, canonical_address_1.areAddressesEqual)(meta.authSender, correspondent)) {
+        throw new Error(`Sender authenticated to server as ${meta.authSender}, while decrypting key is associated with ${correspondent}`);
     }
 }
-exports.InboxOnServer = InboxOnServer;
-Object.freeze(InboxOnServer.prototype);
-Object.freeze(InboxOnServer);
 Object.freeze(exports);

package/build/core/asmail/inbox/msg-indexing/dataset/v0/sql-db-v-none.d.ts

@@ -0,0 +1,11 @@
+import { Database } from '../../../../../../lib-sqlite-on-3nstorage/sqljs';
+export interface MsgIndexDbVNoneEntry {
+    msg_id: string;
+    msg_type: string;
+    delivery_ts: number;
+    key: Uint8Array;
+    key_status: string;
+    main_obj_header_ofs: number;
+    remove_after: number;
+}
+export declare function getAllRecordsFromVersionNone(db: Database): MsgIndexDbVNoneEntry[];

package/build/{lib-client/xsp-fs/util/for-arrays.js → core/asmail/inbox/msg-indexing/dataset/v0/sql-db-v-none.js}

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2022 3NSoft Inc.
+ Copyright (C) 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -16,16 +16,10 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendArray = appendArray;
-function appendArray(arr, elems) {
-    if (elems !== undefined) {
-        if (Array.isArray(elems)) {
-            arr.push(...elems);
-        }
-        else {
-            arr.push(elems);
-        }
-    }
-    return arr;
+exports.getAllRecordsFromVersionNone = getAllRecordsFromVersionNone;
+const lib_sqlite_on_3nstorage_1 = require("../../../../../../lib-sqlite-on-3nstorage");
+function getAllRecordsFromVersionNone(db) {
+    const result = db.exec(`--sql
+		SELECT * FROM inbox_index`)[0];
+    return (result ? (0, lib_sqlite_on_3nstorage_1.objectFromQueryExecResult)(result) : []);
 }
-Object.freeze(exports);

package/build/core/asmail/inbox/msg-indexing/dataset/v1/logs.d.ts

@@ -0,0 +1,33 @@
+import { SingleProc } from '../../../../../../lib-common/processes/synced';
+import { MsgKeyInfo, MsgKeyRole } from '../../../../../keyring';
+import { LogError } from '../../../../../../lib-client/logging/log-to-file';
+type WritableFS = web3n.files.WritableFS;
+type MsgInfo = web3n.asmail.MsgInfo;
+interface MsgOpenedLog {
+    eventType: 'msg-opened';
+    eventTS: number;
+    msgId: string;
+    msgType: string;
+    deliveryTS: number;
+    keyB64: string;
+    keyStatus: MsgKeyRole;
+    mainObjHeaderOfs: number;
+}
+interface MsgRemovedLog {
+    eventType: 'msg-removed';
+    eventTS: number;
+    msgId: string;
+    deliveryTS: number;
+}
+export type MsgOp = MsgOpenedLog | MsgRemovedLog;
+export declare function msgOpenedEventToRecordParams(op: MsgOpenedLog): {
+    msgInfo: MsgInfo;
+    decrInfo: MsgKeyInfo;
+};
+export declare function makeRecentMsgIndexChangesLogs(logsFS: WritableFS, localLogsFS: WritableFS, logError: LogError): Promise<{
+    recordMsgAddition: (msgInfo: MsgInfo, decrInfo: MsgKeyInfo) => Promise<void>;
+    recordMsgRemoval: (msgId: string, deliveryTS: number) => Promise<void>;
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, sink: (ops: import("../../../../../../lib-common/dataset-sync/per-device-json-array-logs").LogEntry<MsgOp>[]) => Promise<void>) => () => void;
+    cutLogOnDatasetSyncAndUpload: (syncPointV: number, params?: any) => Promise<void> | undefined;
+}>;
+export {};

package/build/core/asmail/inbox/msg-indexing/dataset/v1/logs.js

@@ -0,0 +1,72 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2020, 2023, 2026 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.msgOpenedEventToRecordParams = msgOpenedEventToRecordParams;
+exports.makeRecentMsgIndexChangesLogs = makeRecentMsgIndexChangesLogs;
+const buffer_utils_1 = require("../../../../../../lib-common/buffer-utils");
+const per_device_json_array_logs_1 = require("../../../../../../lib-common/dataset-sync/per-device-json-array-logs");
+function msgOpenedEventToRecordParams(op) {
+    const { msgType, msgId, deliveryTS, keyB64, keyStatus, mainObjHeaderOfs } = op;
+    return {
+        msgInfo: {
+            msgId, msgType, deliveryTS
+        },
+        decrInfo: {
+            correspondent: '',
+            keyStatus,
+            msgKeyPackLen: mainObjHeaderOfs,
+            key: buffer_utils_1.base64.open(keyB64)
+        }
+    };
+}
+function areOpsEqual(a, b) {
+    return ((a.eventType === b.eventType) && (a.msgId === b.msgId) && (a.deliveryTS === b.deliveryTS));
+}
+async function makeRecentMsgIndexChangesLogs(logsFS, localLogsFS, logError) {
+    const { appendLogsAndUpload, cutLogOnDatasetSyncAndUpload, watchAndApplyOpsFromOtherDevices } = await (0, per_device_json_array_logs_1.makeRecentChangesLogs)(logsFS, localLogsFS, areOpsEqual, logError);
+    function recordMsgAddition(msgInfo, decrInfo) {
+        if (!decrInfo.key) {
+            throw new Error(`Given message decryption info doesn't have a key for message ${msgInfo.msgId}`);
+        }
+        return appendLogsAndUpload({
+            eventType: 'msg-opened',
+            eventTS: Date.now(),
+            msgType: msgInfo.msgType,
+            msgId: msgInfo.msgId,
+            deliveryTS: msgInfo.deliveryTS,
+            keyB64: buffer_utils_1.base64.pack(decrInfo.key),
+            keyStatus: decrInfo.keyStatus,
+            mainObjHeaderOfs: decrInfo.msgKeyPackLen,
+        });
+    }
+    function recordMsgRemoval(msgId, deliveryTS) {
+        return appendLogsAndUpload({
+            eventType: 'msg-removed',
+            eventTS: Date.now(),
+            msgId,
+            deliveryTS
+        });
+    }
+    return {
+        recordMsgAddition,
+        recordMsgRemoval,
+        watchAndApplyOpsFromOtherDevices,
+        cutLogOnDatasetSyncAndUpload
+    };
+}
+Object.freeze(exports);

package/build/core/asmail/inbox/msg-indexing/dataset/v1/sql-db.d.ts

@@ -0,0 +1,28 @@
+import { MsgKeyInfo, MsgKeyRole } from '../../../../../keyring';
+import { MsgOp } from './logs';
+import { SingleProc } from '../../../../../../lib-common/processes/synced';
+import { LogEntry } from '../../../../../../lib-common/dataset-sync/per-device-json-array-logs';
+type WritableFS = web3n.files.WritableFS;
+type WritableFile = web3n.files.WritableFile;
+type MsgInfo = web3n.asmail.MsgInfo;
+export interface MsgKey {
+    msgKey: Uint8Array;
+    msgKeyRole: MsgKeyRole;
+    mainObjHeaderOfs: number;
+}
+export declare function makeSqliteDBs(dbsFS: WritableFS): Promise<{
+    absorbOpsFromOtherDevices: (changeProc: SingleProc, ops: LogEntry<MsgOp>[]) => Promise<void>;
+    addToLatest: (msgInfo: MsgInfo, decrInfo: MsgKeyInfo) => Promise<boolean>;
+    getDBFile: (fileTS: number) => Promise<WritableFile>;
+    getKeyFor: (msgId: string, deliveryTS: number) => Promise<MsgKey | undefined>;
+    isForLatestDb: (deliveryTS: number) => boolean;
+    latestDbHasNewRemoteVersion: () => Promise<boolean>;
+    listMsgs: (fromTS: number | undefined) => Promise<MsgInfo[]>;
+    msgExists: ({ msgId, deliveryTS }: MsgInfo) => Promise<boolean>;
+    makeNewShardWithRecordsUpToTS: (shardTS: number) => Promise<number>;
+    syncPastShards: () => Promise<void>;
+    numberOfRecordsInLatestBefore: (ts: number) => number;
+    remove: (msgId: string) => Promise<number | undefined>;
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, resetSyncInterval: () => void) => () => void;
+}>;
+export {};