core-3nweb-client-lib 0.49.5 → 0.49.7

package/build/tests/computer.3nweb.core/keyrings.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright 2025 3NSoft Inc.
+ Copyright 2025 - 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,49 +16,134 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+const peer_keys_1 = require("../../core/keyring/peer-keys");
+const fs_sync_utils_1 = require("../../lib-client/fs-utils/fs-sync-utils");
 const jasmine_utils_1 = require("../libs-for-tests/jasmine-utils");
 const setups_1 = require("../libs-for-tests/setups");
 const test_utils_1 = require("./test-utils");
-const address = `address Bob Perkins @company.inc`;
-const introPKeyFromServer = {
-    use: 'asmail-pub-key',
-    alg: 'NaCl-box-CXSP',
-    kid: 'EKnB33DQsmpq2RiL',
-    k: 'hDeWvNYajaAFUijY23SlXFKhIFOuMJLWtIBJYtiToEQ='
+const random_node_1 = require("../../lib-common-on-node/random-node");
+const inspector_1 = require("inspector");
+const common_1 = require("../../core/keyring/common");
+const canonical_address_1 = require("../../lib-common/canonical-address");
+const bytes_equal_1 = require("../libs-for-tests/bytes-equal");
+const logger = {
+    appLog: async () => { },
+    logError: async (err, msg) => {
+        inspector_1.console.error(`\n --- test logError called with ---\nMessage: ${msg}\nError:`, err);
+    },
+    logWarning: async (msg, err) => {
+        inspector_1.console.error(`\n --- test logWarning called with ---\nMessage: ${msg}\nError:`, err);
+    },
+    recordUnhandledRejectionsInProcess: () => { }
 };
+async function logErrorInTest(err, msg) {
+    inspector_1.console.error(`\n --- test logError callled with ---\nMessage: ${msg}\nError:`, err);
+}
 describe('ASMail keyring', () => {
     const baseSetup = (0, setups_1.setupWithUsers)();
     const testFolder = `keyring-test`;
-    let keyring;
     const { fsSetup: setup, setupDevsAndFSs } = (0, test_utils_1.makeSetupWithTwoDevsFSs)(testFolder);
     (0, jasmine_utils_1.beforeAllWithTimeoutLog)(async () => {
         await setupDevsAndFSs(baseSetup);
     }, 20000);
-    beforeEach(async () => {
-        const fs = setup.dev1FS();
-        // keyring = await makeAndKeyRing(cryptor, fs, {
-        // 	find: kid => { throw Error(`publishedKeys.find() mock`); },
-        // 	update: async () => { throw Error(`publishedKeys.update() mock`); }
-        // });
-    });
     (0, jasmine_utils_1.afterEachCond)(async () => {
         if (!setup.isUp) {
             return;
         }
         await setup.resetFS();
     });
-    (0, jasmine_utils_1.itCond)(`.generateKeysToSend()`, async () => {
-        // 		const {
-        // 			currentPair, encryptor, msgCount
-        // 		} = await keyring.generateKeysToSend(address, introPKeyFromServer);
-        // // DEBUG
-        // // console.log(`currentPair`, currentPair, `
-        // // msgCount`, msgCount);
-        // 	const {
-        // 		currentPair: cp, msgCount: count
-        // 	} = await keyring.generateKeysToSend(address);
-        // // DEBUG
-        // // console.log(`currentPair`, cp, `
-        // // msgCount`, count);
+    (0, jasmine_utils_1.itCond)(`peers keyring supports key pair operations for a full messaging chain from intro`, async () => {
+        const dev1FS = setup.dev1FS();
+        const dev1LocalFS = setup.dev1LocalFS();
+        // run different peers' keyrings from different folders
+        const peer1 = `keyring tester 1 @rock.cafe`;
+        const peer2 = `keyring tester 2 @rock.cafe`;
+        const p1FS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(dev1FS, peer1);
+        const p1LocalFS = await dev1LocalFS.writableSubRoot(`local fs for ${peer1}`);
+        const p2FS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(dev1FS, peer2);
+        const p2LocalFS = await dev1LocalFS.writableSubRoot(`local fs for ${peer2}`);
+        const peerKeys1 = await (0, peer_keys_1.makePeersKeyring)(p1FS, p1LocalFS, random_node_1.bytes, logger);
+        const peerKeys2 = await (0, peer_keys_1.makePeersKeyring)(p2FS, p2LocalFS, random_node_1.bytes, logger);
+        try {
+            // -----------------------------------
+            // Message 1: peer1 to peer2, peers initially don't know each other (don't have established key pairs)
+            // -----------------------------------
+            // peer1 somehow gets intro key for peer2
+            const p2IntroPair = await (0, common_1.generateKeyPair)(random_node_1.bytes);
+            // peer1, to send first message with introductory pair, generates and save suggested crypto
+            let suggestedCrypto = await peerKeys1.suggestPairForPeerIntroKey(peer2, p2IntroPair.pkey);
+            expect(peerKeys1.needIntroKeyFor(peer2)).toBeTrue();
+            expect(suggestedCrypto.senderKid).toBe(p2IntroPair.pkey.kid);
+            // peer2 saves suggested crypto from decrypted message, crypto based on introductory key
+            expect(peerKeys2.needIntroKeyFor(peer1)).toBeTrue();
+            await peerKeys2.absorbNextPairSuggestedByPeer(peer1, suggestedCrypto, p2IntroPair);
+            const estPair1 = suggestedCrypto;
+            expect(peerKeys2.needIntroKeyFor(peer1)).toBeFalse();
+            // -----------------------------------
+            // Message 2: peer2 to peer1
+            // -----------------------------------
+            // peer2, to send reply, generates and saves suggested crypto
+            let forSending = await peerKeys2.getSendingCryptoWithinEstablishedPair((0, canonical_address_1.toCanonicalAddress)(peer1));
+            expect(estPair1.pids).toContain(forSending.currentPair.pid);
+            expect(forSending.nextMsgCrypto).withContext(`next crypto is generated asap to jump off introductory key`).toBeDefined();
+            // peer1, when message is received with pair id (pid), finds keys to decrypt message
+            let decr = peerKeys1.findEstablishedReceptionPairs(forSending.currentPair.pid);
+            expect(decr).toBeDefined();
+            expect(decr[0].peerCAddr).toBe((0, canonical_address_1.toCanonicalAddress)(peer2));
+            expect(decr[0].ratchetStage).toBe('suggested');
+            expect((0, bytes_equal_1.bytesEqual)(forSending.msgMasterKey, decr[0].msgMasterKey)).toBeTrue();
+            // peer1 marks found crypto pair as being in use
+            await peerKeys1.markPairAsInUse(decr[0].peerCAddr, decr[0].peerKId, decr[0].recipientKId);
+            // peer1 saves next crypto from decrypted message
+            expect(peerKeys1.needIntroKeyFor(peer2)).toBeTrue();
+            await peerKeys1.absorbNextPairSuggestedByPeer(peer2, forSending.nextMsgCrypto);
+            const estPair2 = forSending.nextMsgCrypto;
+            expect(peerKeys1.needIntroKeyFor(peer2)).toBeFalse();
+            // -----------------------------------
+            // Message 3: peer1 to peer2
+            // -----------------------------------
+            // peer1 gets crypto to send to peer2
+            forSending = await peerKeys1.getSendingCryptoWithinEstablishedPair((0, canonical_address_1.toCanonicalAddress)(peer2));
+            expect(estPair2.pids).toContain(forSending.currentPair.pid);
+            expect(forSending.nextMsgCrypto).withContext(`attempt to rotate pairs will come after some period of time`).toBeUndefined();
+            // peer2 finds pair to decrypt message
+            decr = peerKeys2.findEstablishedReceptionPairs(forSending.currentPair.pid);
+            expect(decr).toBeDefined();
+            expect(decr[0].peerCAddr).toBe((0, canonical_address_1.toCanonicalAddress)(peer1));
+            expect(decr[0].ratchetStage).toBe('suggested');
+            expect((0, bytes_equal_1.bytesEqual)(forSending.msgMasterKey, decr[0].msgMasterKey)).toBeTrue();
+            // peer2 marks found crypto pair as being in use
+            await peerKeys2.markPairAsInUse(decr[0].peerCAddr, decr[0].peerKId, decr[0].recipientKId);
+            // -----------------------------------
+            // Message 4: peer2 to peer1
+            // -----------------------------------
+            // peer2 gets crypto to send to peer1
+            forSending = await peerKeys2.getSendingCryptoWithinEstablishedPair((0, canonical_address_1.toCanonicalAddress)(peer1));
+            expect(estPair1.pids).toContain(forSending.currentPair.pid);
+            expect(forSending.nextMsgCrypto).withContext(`attempt to rotate pairs will come after some period of time`).toBeUndefined();
+            // peer1, when message is received with pair id (pid), finds keys to decrypt message
+            decr = peerKeys1.findEstablishedReceptionPairs(forSending.currentPair.pid);
+            expect(decr).toBeDefined();
+            expect(decr[0].peerCAddr).toBe((0, canonical_address_1.toCanonicalAddress)(peer2));
+            expect(decr[0].ratchetStage).toBe('in_use');
+            expect((0, bytes_equal_1.bytesEqual)(forSending.msgMasterKey, decr[0].msgMasterKey)).toBeTrue();
+            // -----------------------------------
+            // Message 5: peer1 to peer2
+            // -----------------------------------
+            // peer1 gets crypto to send to peer2
+            forSending = await peerKeys1.getSendingCryptoWithinEstablishedPair((0, canonical_address_1.toCanonicalAddress)(peer2));
+            expect(estPair2.pids).toContain(forSending.currentPair.pid);
+            expect(forSending.nextMsgCrypto).withContext(`attempt to rotate pairs will come after some period of time`).toBeUndefined();
+            // peer2 finds pair to decrypt message
+            decr = peerKeys2.findEstablishedReceptionPairs(forSending.currentPair.pid);
+            expect(decr).toBeDefined();
+            expect(decr[0].peerCAddr).toBe((0, canonical_address_1.toCanonicalAddress)(peer1));
+            expect(decr[0].ratchetStage).toBe('in_use');
+            expect((0, bytes_equal_1.bytesEqual)(forSending.msgMasterKey, decr[0].msgMasterKey)).toBeTrue();
+        }
+        finally {
+            await peerKeys1.close().catch(exc => logErrorInTest(exc));
+            await peerKeys2.close().catch(exc => logErrorInTest(exc));
+        }
     }, undefined, setup);
 });

package/build/tests/jasmine.js

@@ -34,9 +34,9 @@ const ALL_SPECS = [
     'caps-api/mailerid.js',
     'caps-api/storage.js',
     'caps-api/asmail.js',
-    // 'computer.3nweb.core/*.js',
+    'computer.3nweb.core/keyrings.js',
     'computer.3nweb.core/id-manager.js',
-    // 'computer.3nweb.core/inbox/*.js'
+    'computer.3nweb.core/inbox/*.js'
 ];
 jas.loadConfig({
     spec_dir: 'build/tests',

package/build/tests/units/number-line.js

@@ -16,48 +16,48 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("../../core/asmail/delivery/common");
 const json_utils_1 = require("../../lib-common/json-utils");
+const number_line_1 = require("../../lib-common/number-line");
 describe(`Function addToNumberLineSegments`, () => {
     it(`inserts number to empty segments array`, () => {
         const segments = [];
         const n = 1;
-        (0, common_1.addToNumberLineSegments)(segments, n);
+        (0, number_line_1.addToNumberLineSegments)(segments, n);
         expect((0, json_utils_1.deepEqual)(segments, [[n, n]])).toBeTruthy();
     });
     it(`expands existing segment on lower side`, () => {
         let segments = [[1, 1], [4, 4]];
-        (0, common_1.addToNumberLineSegments)(segments, 3);
+        (0, number_line_1.addToNumberLineSegments)(segments, 3);
         expect((0, json_utils_1.deepEqual)(segments, [[1, 1], [3, 4]])).toBeTruthy();
     });
     it(`expands existing segment on higher side`, () => {
         const segments = [[1, 1], [4, 4]];
-        (0, common_1.addToNumberLineSegments)(segments, 2);
+        (0, number_line_1.addToNumberLineSegments)(segments, 2);
         expect((0, json_utils_1.deepEqual)(segments, [[1, 2], [4, 4]])).toBeTruthy();
     });
     it(`expands existing segment and merges it with an overlapping one`, () => {
         const segments = [[1, 2], [4, 4]];
-        (0, common_1.addToNumberLineSegments)(segments, 3);
+        (0, number_line_1.addToNumberLineSegments)(segments, 3);
         expect((0, json_utils_1.deepEqual)(segments, [[1, 4]])).toBeTruthy();
     });
     it(`changes nothing when number is already in an existing segment`, () => {
         const segments = [[1, 2], [4, 4]];
-        (0, common_1.addToNumberLineSegments)(segments, 2);
+        (0, number_line_1.addToNumberLineSegments)(segments, 2);
         expect((0, json_utils_1.deepEqual)(segments, [[1, 2], [4, 4]])).toBeTruthy();
     });
     it(`adds new segment on a lower side`, () => {
         const segments = [[4, 6], [10, 12]];
-        (0, common_1.addToNumberLineSegments)(segments, 2);
+        (0, number_line_1.addToNumberLineSegments)(segments, 2);
         expect((0, json_utils_1.deepEqual)(segments, [[2, 2], [4, 6], [10, 12]])).toBeTruthy();
     });
     it(`adds new segment in the middle`, () => {
         const segments = [[4, 6], [10, 12]];
-        (0, common_1.addToNumberLineSegments)(segments, 8);
+        (0, number_line_1.addToNumberLineSegments)(segments, 8);
         expect((0, json_utils_1.deepEqual)(segments, [[4, 6], [8, 8], [10, 12]])).toBeTruthy();
     });
     it(`adds new segment on a higher side`, () => {
         const segments = [[4, 6], [10, 12]];
-        (0, common_1.addToNumberLineSegments)(segments, 15);
+        (0, number_line_1.addToNumberLineSegments)(segments, 15);
         expect((0, json_utils_1.deepEqual)(segments, [[4, 6], [10, 12], [15, 15]])).toBeTruthy();
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.49.5",
+  "version": "0.49.7",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",
@@ -48,6 +48,7 @@
     "@types/punycode": "^2.1.1",
     "@types/ws": "^8.18.1",
     "jasmine": "^5.13.0",
+    "lodash": "^4.18.1",
     "napi-nacl": "^1.2.1",
     "protobufjs-cli": "^1.0.2",
     "spec-3nweb-server": "^1.8.6",

package/build/core/asmail/inbox/msg-indexing/logs-n-entries.d.ts

@@ -1,52 +0,0 @@
-import { MsgKeyInfo, MsgKeyRole } from '../../../keyring';
-type WritableFS = web3n.files.WritableFS;
-type MsgInfo = web3n.asmail.MsgInfo;
-interface MsgOpenedLog {
-    msgState: 'opened';
-    msgId: string;
-    msgType: string;
-    deliveryTS: number;
-    keyB64: string;
-    keyStatus: MsgKeyRole;
-    mainObjHeaderOfs: number;
-    removeAfter?: number;
-}
-interface MsgRemovedLog {
-    msgState: 'removed';
-    msgId: string;
-    deliveryTS: number;
-}
-type MsgLog = MsgOpenedLog | MsgRemovedLog;
-export interface MsgKey {
-    msgKey: Uint8Array;
-    msgKeyRole: MsgKeyRole;
-    mainObjHeaderOfs: number;
-}
-export interface IndexedRecords {
-    add(msgInfo: MsgInfo, decrInfo: MsgKeyInfo, removeAfter: number): Promise<void>;
-    remove(msgId: string): Promise<number | undefined>;
-    listMsgs(fromTS: number | undefined): Promise<MsgInfo[]>;
-    getKeyFor(msgId: string, deliveryTS: number): Promise<MsgKey | undefined>;
-    msgExists(msgInfo: MsgInfo): Promise<boolean>;
-    stopSyncing(): void;
-}
-export declare function makeJsonBasedIndexedRecords(logs: MsgLogs): IndexedRecords;
-export declare class MsgLogs {
-    private readonly fs;
-    private latest;
-    private fileTSs;
-    private readonly changeProc;
-    private constructor();
-    static makeAndStartSyncing(logsFS: WritableFS): Promise<MsgLogs>;
-    stopSyncing(): void;
-    add(msgInfo: MsgInfo, decrInfo: MsgKeyInfo, removeAfter: number | undefined): Promise<void>;
-    private updateLogsFile;
-    getLogsFromFile(fileTS: number | undefined): Promise<MsgLog[] | undefined>;
-    private fileTSforMsgTS;
-    remove(msgId: string, deliveryTS: number): Promise<void>;
-    private scheduleRemovalOfMsgOpenedLog;
-    getMsgOpenedLog(msgId: string, deliveryTS: number): Promise<MsgOpenedLog | undefined>;
-    getLogFileTSs(): number[];
-    getLatestMsgLogs(): MsgLog[];
-}
-export {};

package/build/core/asmail/inbox/msg-indexing/logs-n-entries.js

@@ -1,333 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2016 - 2020, 2023 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.MsgLogs = void 0;
-exports.makeJsonBasedIndexedRecords = makeJsonBasedIndexedRecords;
-const synced_1 = require("../../../../lib-common/processes/synced");
-const buffer_utils_1 = require("../../../../lib-common/buffer-utils");
-const timed_cache_1 = require("../../../../lib-common/timed-cache");
-const error_1 = require("../../../../lib-common/exceptions/error");
-const LIMIT_RECORDS_PER_FILE = 200;
-const LATEST_LOG = 'latest.json';
-const LOG_EXT = '.json';
-const INDEX_FNAME_REGEXP = /^\d+\.json$/;
-function logsFileName(fileTS) {
-    return (fileTS ? LATEST_LOG : `${fileTS}${LOG_EXT}`);
-}
-function fileTSOrderComparator(a, b) {
-    return (a - b);
-}
-function insertInto(records, rec) {
-    if (records.length === 0) {
-        records.push(rec);
-        return;
-    }
-    const ts = rec.deliveryTS;
-    for (let i = (records.length - 1); i >= 0; i -= 1) {
-        if (records[i].deliveryTS <= ts) {
-            records.splice(i + 1, 0, rec);
-            return;
-        }
-    }
-    records.splice(0, 0, rec);
-}
-function removeMsgOpenedLogFrom(logs, msgId) {
-    const indToRm = logs.findIndex(log => ((log.msgId === msgId) && (log.msgState === 'opened')));
-    if (indToRm > -1) {
-        logs.splice(indToRm, 1);
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-/**
- * This is a catch callback, which returns undefined on file(folder) not found
- * exception, and re-throws all other exceptions/errors.
- */
-function notFoundOrReThrow(exc) {
-    if (!exc.notFound) {
-        throw exc;
-    }
-    return;
-}
-function makeJsonBasedIndexedRecords(logs) {
-    return new JsonBasedIndexedRecords(logs);
-}
-function toMsgOpenedLog(msgInfo, decrInfo, removeAfter) {
-    if (!decrInfo.key) {
-        throw new Error(`Given message decryption info doesn't have a key for message ${msgInfo.msgId}`);
-    }
-    return {
-        msgState: 'opened',
-        msgType: msgInfo.msgType,
-        msgId: msgInfo.msgId,
-        deliveryTS: msgInfo.deliveryTS,
-        keyB64: buffer_utils_1.base64.pack(decrInfo.key),
-        keyStatus: decrInfo.keyStatus,
-        mainObjHeaderOfs: decrInfo.msgKeyPackLen,
-        removeAfter
-    };
-}
-function keyInfoFrom(log) {
-    return {
-        msgKey: buffer_utils_1.base64.open(log.keyB64),
-        msgKeyRole: log.keyStatus,
-        mainObjHeaderOfs: log.mainObjHeaderOfs
-    };
-}
-function addOnlyNonRemovedMsgs(dst, ignore, src) {
-    for (const log of src) {
-        if (log.msgState === 'removed') {
-            ignore.add(log.msgId);
-        }
-    }
-    for (const log of src) {
-        if ((log.msgState === 'opened') && !ignore.has(log.msgId)) {
-            dst.push(log);
-        }
-    }
-}
-function cutEarlierMsgs(msgs, fromTS) {
-    let timedEnd = msgs.length;
-    for (let i = (msgs.length - 1); i >= 0; i -= 1) {
-        const msg = msgs[i];
-        if (msg.deliveryTS < fromTS) {
-            timedEnd = i;
-        }
-        else {
-            break;
-        }
-    }
-    if (timedEnd < msgs.length) {
-        msgs.splice(timedEnd, (msgs.length - timedEnd));
-    }
-}
-class JsonBasedIndexedRecords {
-    constructor(logs) {
-        this.logs = logs;
-        this.cachedLogs = (0, timed_cache_1.makeTimedCache)(10 * 60 * 1000);
-        Object.seal(this);
-    }
-    async add(msgInfo, decrInfo, removeAfter) {
-        const msg = toMsgOpenedLog(msgInfo, decrInfo, removeAfter);
-        this.cachedLogs.set(msg.msgId, msg);
-    }
-    async remove(msgId) {
-        let foundLog = this.cachedLogs.get(msgId);
-        if (foundLog) {
-            this.cachedLogs.delete(msgId);
-            return foundLog.deliveryTS;
-        }
-        for (const fileTS of [undefined, ...this.logs.getLogFileTSs()]) {
-            let logs;
-            if ((fileTS === undefined)) {
-                logs = this.logs.getLatestMsgLogs();
-            }
-            else {
-                const logsFromFile = await this.logs.getLogsFromFile(fileTS);
-                if (!logsFromFile) {
-                    continue;
-                }
-                logs = logsFromFile;
-            }
-            for (const log of logs) {
-                if (log.msgId === msgId) {
-                    return log.deliveryTS;
-                }
-            }
-        }
-        return undefined;
-    }
-    async listMsgs(fromTS) {
-        const ignore = new Set();
-        const msgs = [];
-        addOnlyNonRemovedMsgs(msgs, ignore, this.logs.getLatestMsgLogs());
-        const fileTSs = this.logs.getLogFileTSs();
-        if (fromTS === undefined) {
-            for (const fileTS of fileTSs) {
-                const logs = await this.logs.getLogsFromFile(fileTS);
-                if (!logs) {
-                    continue;
-                }
-                addOnlyNonRemovedMsgs(msgs, ignore, logs);
-            }
-        }
-        else {
-            for (const fileTS of fileTSs) {
-                if (fromTS > fileTS) {
-                    break;
-                }
-                const logs = await this.logs.getLogsFromFile(fileTS);
-                if (!logs) {
-                    continue;
-                }
-                addOnlyNonRemovedMsgs(msgs, ignore, logs);
-            }
-        }
-        // note sorting later messages to array's head
-        msgs.sort((m1, m2) => (m2.deliveryTS - m1.deliveryTS));
-        if (fromTS !== undefined) {
-            cutEarlierMsgs(msgs, fromTS);
-        }
-        for (const log of msgs) {
-            this.cachedLogs.set(log.msgId, log);
-        }
-        return msgs.map(log => ({
-            msgId: log.msgId,
-            msgType: log.msgType,
-            deliveryTS: log.deliveryTS
-        }));
-    }
-    async getKeyFor(msgId, deliveryTS) {
-        let log = this.cachedLogs.get(msgId);
-        if (log) {
-            return keyInfoFrom(log);
-        }
-        log = await this.logs.getMsgOpenedLog(msgId, deliveryTS);
-        if (!log) {
-            return undefined;
-        }
-        this.cachedLogs.set(log.msgId, log);
-        return keyInfoFrom(log);
-    }
-    async msgExists(msgInfo) {
-        const foundLog = this.cachedLogs.get(msgInfo.msgId);
-        return (!!foundLog && (foundLog.deliveryTS === msgInfo.deliveryTS));
-    }
-    stopSyncing() { }
-}
-Object.freeze(JsonBasedIndexedRecords.prototype);
-Object.freeze(JsonBasedIndexedRecords);
-class MsgLogs {
-    constructor(fs, latest, fileTSs) {
-        this.fs = fs;
-        this.latest = latest;
-        this.fileTSs = fileTSs;
-        this.changeProc = new synced_1.SingleProc();
-        Object.seal(this);
-    }
-    static async makeAndStartSyncing(logsFS) {
-        const fName = logsFileName(undefined);
-        let latest = await logsFS.readJSONFile(fName)
-            .catch(notFoundOrReThrow);
-        if (!latest) {
-            latest = [];
-            await logsFS.writeJSONFile(fName, latest, { create: true, exclusive: true });
-        }
-        const fileTSs = (await logsFS.listFolder('.'))
-            .map(f => f.name)
-            .filter(fName => fName.match(INDEX_FNAME_REGEXP))
-            .map(fName => parseInt(fName.substring(0, fName.length - LOG_EXT.length)))
-            .filter(fileTS => !isNaN(fileTS))
-            .sort(fileTSOrderComparator);
-        const logs = new MsgLogs(logsFS, latest, fileTSs);
-        return logs;
-    }
-    stopSyncing() {
-        // XXX fill this with content
-    }
-    async add(msgInfo, decrInfo, removeAfter) {
-        const msg = toMsgOpenedLog(msgInfo, decrInfo, removeAfter);
-        return this.changeProc.startOrChain(async () => {
-            const fileTS = this.fileTSforMsgTS(msg.deliveryTS);
-            const logs = ((fileTS === undefined) ?
-                this.latest : await this.getLogsFromFile(fileTS));
-            if (!logs) {
-                throw (0, error_1.errWithCause)(`${logsFileName(fileTS)} not found`, `Expectation fail: there should be some message records.`);
-            }
-            insertInto(logs, msg);
-            await this.updateLogsFile(fileTS, logs);
-        });
-    }
-    async updateLogsFile(fileTS, logs) {
-        await this.fs.writeJSONFile(logsFileName(fileTS), logs, { create: false });
-    }
-    async getLogsFromFile(fileTS) {
-        const fName = logsFileName(undefined);
-        const logs = await this.fs.readJSONFile(fName)
-            .catch(notFoundOrReThrow);
-        return logs;
-    }
-    fileTSforMsgTS(deliveryTS) {
-        if ((this.fileTSs.length === 0)
-            || (deliveryTS >= this.fileTSs[this.fileTSs.length - 1])) {
-            return undefined;
-        }
-        let fileTS = this.fileTSs[this.fileTSs.length - 1];
-        for (let i = (this.fileTSs.length - 2); i <= 0; i -= 1) {
-            if (deliveryTS >= this.fileTSs[i]) {
-                break;
-            }
-            else {
-                fileTS = this.fileTSs[i];
-            }
-        }
-        return fileTS;
-    }
-    async remove(msgId, deliveryTS) {
-        const msgRmLog = {
-            msgState: 'removed',
-            msgId,
-            deliveryTS
-        };
-        return this.changeProc.startOrChain(async () => {
-            this.latest.push(msgRmLog);
-            const fileTS = this.fileTSforMsgTS(deliveryTS);
-            if (fileTS === undefined) {
-                removeMsgOpenedLogFrom(this.latest, msgId);
-            }
-            await this.updateLogsFile(undefined, this.latest);
-            if (fileTS !== undefined) {
-                this.scheduleRemovalOfMsgOpenedLog(fileTS, msgId);
-            }
-        });
-    }
-    scheduleRemovalOfMsgOpenedLog(fileTS, msgId) {
-        this.changeProc.startOrChain(async () => {
-            const logs = await this.getLogsFromFile(fileTS);
-            if (!logs) {
-                return;
-            }
-            const changed = removeMsgOpenedLogFrom(logs, msgId);
-            if (!changed) {
-                return;
-            }
-            await this.updateLogsFile(fileTS, logs);
-        });
-    }
-    async getMsgOpenedLog(msgId, deliveryTS) {
-        const fileTS = this.fileTSforMsgTS(deliveryTS);
-        const logs = ((fileTS === undefined) ?
-            this.latest : await this.getLogsFromFile(fileTS));
-        if (!logs) {
-            return undefined;
-        }
-        return logs.find(log => ((log.msgId === msgId) && (log.msgState === 'opened')));
-    }
-    getLogFileTSs() {
-        return this.fileTSs.concat([]);
-    }
-    getLatestMsgLogs() {
-        return this.latest.concat([]);
-    }
-}
-exports.MsgLogs = MsgLogs;
-Object.freeze(MsgLogs.prototype);
-Object.freeze(MsgLogs);
-Object.freeze(exports);

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

@@ -1,4 +0,0 @@
-import { IndexedRecords } from './logs-n-entries';
-type WritableFS = web3n.files.WritableFS;
-export declare function makeSqliteBasedIndexedRecords(syncedFS: WritableFS): Promise<IndexedRecords>;
-export {};