core-3nweb-client-lib 0.49.8 → 0.50.1

package/build/api-defs/files.d.ts

@@ -1172,7 +1172,7 @@ declare namespace web3n.files {
 
 	interface FileChangeEvent extends FSChangeEvent {
 		type: 'file-change';
-		newVersion?: number;
+		newVersion: number;
 	}
 
 	type RemoteEvent = RemoteVersionArchivalEvent | RemoteArchVerRemovalEvent |

package/build/core/asmail/delivery/per-recipient-wip.js

@@ -132,9 +132,13 @@ class WIP {
         const recipient = this.state.recipient;
         const sp = this.msg.r.correspondents.paramsForSendingTo(recipient);
         if (sp) {
+            // DEBUG
+            // console.log(`sending params for sending to ${recipient} invitation are`, sp);
             this.sender = await sender_1.MailSender.fresh(this.msg.r.makeNet(), this.msg.r.asmailResolver, (sp.auth ? senderAddress : undefined), recipient, sp.invitation);
         }
         else {
+            // DEBUG
+            // console.log(`have no sending params to use for sending to ${recipient}`);
             this.sender = await sender_1.MailSender.fresh(this.msg.r.makeNet(), this.msg.r.asmailResolver, undefined, recipient);
         }
         await this.sender.startSession();

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

@@ -36,7 +36,7 @@ async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
     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 indexSyncedFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(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);
@@ -147,6 +147,8 @@ async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
         }
     }
     async function markOwnParams(meta, sender) {
+        // DEBUG
+        // console.log(`  markOwnParams (if invite used) ->`, {sender, 'meta.invite':meta.invite});
         if (!meta.invite) {
             return;
         }
@@ -154,6 +156,8 @@ async function makeInboxOnServer(cachePath, syncedFS, localFS, r) {
     }
     async function absorbSendingParams(openedMsg) {
         const sendingParams = openedMsg.nextSendingParams;
+        // DEBUG
+        // console.log(`  openedMsg.nextSendingParams ->`, openedMsg.nextSendingParams);
         if (!sendingParams) {
             return;
         }

package/build/core/asmail/inbox/msg-indexing/index.js

@@ -27,9 +27,9 @@ const INDEX_DIR = 'index';
 const NUM_OF_ENTRIES_TO_CHOP_DB = 200;
 async function makeMsgIndex(syncedFS, localFS, logError) {
     // file systems within dataset
-    const logsFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, LOGS_DIR);
+    const logsFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, LOGS_DIR);
     const localLogsFS = await localFS.writableSubRoot(LOGS_DIR);
-    const indexFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INDEX_DIR);
+    const indexFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, INDEX_DIR);
     const logs = await (0, logs_1.makeRecentMsgIndexChangesLogs)(logsFS, localLogsFS, logError);
     const indexed = await (0, sql_db_1.makeSqliteDBs)(indexFS);
     async function add(msgInfo, decrInfo) {
@@ -45,13 +45,12 @@ async function makeMsgIndex(syncedFS, localFS, logError) {
         }
     }
     async function periodicCheckAndUploadOfData() {
-        // XXX disable uploading for a moment by commenting out
-        // const shardTS = Date.now() - 10*60*1000;
-        // const countBefore = indexed.numberOfRecordsInLatestBefore(shardTS);
-        // if (countBefore >= NUM_OF_ENTRIES_TO_CHOP_DB) {
-        // 	const syncedIndexDbVersion = await indexed.makeNewShardWithRecordsUpToTS(shardTS);
-        // 	await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion, { shardTS });
-        // }
+        const shardTS = Date.now() - 10 * 60 * 1000;
+        const countBefore = indexed.numberOfRecordsInLatestBefore(shardTS);
+        if (countBefore >= NUM_OF_ENTRIES_TO_CHOP_DB) {
+            const syncedIndexDbVersion = await indexed.makeNewShardWithRecordsUpToTS(shardTS);
+            await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion, { shardTS });
+        }
     }
     function millisBeforeNextRun() {
         return 30 * 60 * 1000 + Math.floor(10 * 60 * 1000 * Math.random());

package/build/core/asmail/index.js

@@ -61,8 +61,8 @@ class ASMail {
         }
     }
     async setupSendingParams(syncedFS) {
-        const fs = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, SEND_PARAMS_DATA_FOLDER);
-        this.sendingParams = await sending_params_1.SendingParamsHolder.makeAndInit(fs, this.config.makeParamSetterAndGetter('anon-sender/invites'), this.random);
+        const fs = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, SEND_PARAMS_DATA_FOLDER);
+        this.sendingParams = await (0, sending_params_1.makeSendingParamsHolder)(fs, this.config.makeParamSetterAndGetter('anon-sender/invites'), this.random);
     }
     async setupDelivery(localFS, getSigner, makeResolver) {
         const fs = await localFS.writableSubRoot(DELIVERY_DATA_FOLDER);
@@ -88,7 +88,7 @@ class ASMail {
     }
     async setupInbox(syncedFS, localFS, getSigner, getStorages, makeResolver) {
         const cachePath = this.inboxPathForUser(this.address);
-        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
+        const inboxSyncedFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(syncedFS, INBOX_DATA_FOLDER);
         const inboxLocalFS = await localFS.writableSubRoot(INBOX_DATA_FOLDER);
         this.inbox = await (0, inbox_1.makeInboxOnServer)(cachePath, inboxSyncedFS, inboxLocalFS, {
             address: this.address,

package/build/core/asmail/sending-params/index.d.ts

@@ -6,18 +6,17 @@ export { SendingParams } from './params-from-others';
 type WritableFS = web3n.files.WritableFS;
 type SendingResources = ResourcesForSending['correspondents'];
 type ReceptionResources = ResourcesForReceiving['correspondents'];
-export declare class SendingParamsHolder {
-    private readonly paramsFromOthers;
-    private readonly ownParams;
-    readonly thisSide: {
-        getUpdated: SendingResources['newParamsForSendingReplies'];
-        setAsUsed: ReceptionResources['markOwnSendingParamsAsUsed'];
-    };
-    readonly otherSides: {
-        get: SendingResources['paramsForSendingTo'];
-        set: ReceptionResources['saveParamsForSendingTo'];
-    };
-    private constructor();
-    static makeAndInit(fs: WritableFS, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<SendingParamsHolder>;
-    close(): Promise<void>;
+export interface SendingParamsThisSide {
+    getUpdated: SendingResources['newParamsForSendingReplies'];
+    setAsUsed: ReceptionResources['markOwnSendingParamsAsUsed'];
 }
+export interface SendingParamsOtherSides {
+    get: SendingResources['paramsForSendingTo'];
+    set: ReceptionResources['saveParamsForSendingTo'];
+}
+export interface SendingParamsHolder {
+    thisSide: SendingParamsThisSide;
+    otherSides: SendingParamsOtherSides;
+    close: () => Promise<void>;
+}
+export declare function makeSendingParamsHolder(fs: WritableFS, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<SendingParamsHolder>;

package/build/core/asmail/sending-params/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 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,46 +16,26 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendingParamsHolder = void 0;
+exports.makeSendingParamsHolder = makeSendingParamsHolder;
 const params_from_others_1 = require("./params-from-others");
 const own_params_1 = require("./own-params");
 const invitations_anon_1 = require("./invitations-anon");
 const PARAMS_FROM_OTHERS_FILE = 'params-from-others.json';
 const OWN_PARAMS_FILE = 'own-params.json';
 const ANONYM_INVITES_FILE = 'anonymous-invites.json';
-class SendingParamsHolder {
-    constructor(paramsFromOthers, ownParams) {
-        this.paramsFromOthers = paramsFromOthers;
-        this.ownParams = ownParams;
-        this.otherSides = {
-            get: this.paramsFromOthers.getFor,
-            set: this.paramsFromOthers.setFor
-        };
-        this.thisSide = {
-            getUpdated: this.ownParams.getFor,
-            setAsUsed: this.ownParams.setAsInUse
-        };
-        Object.freeze(this);
-    }
-    static async makeAndInit(fs, anonInvitesOnServer, random) {
-        const [paramsFromOthers, ownParams] = await Promise.all([
-            fs.writableFile(PARAMS_FROM_OTHERS_FILE)
-                .then(f => params_from_others_1.ParamsFromOthers.makeAndInit(f)),
-            fs.writableFile(ANONYM_INVITES_FILE)
-                .then(async (anonInvitesFile) => {
-                const anonInvites = await invitations_anon_1.AnonymousInvites.makeAndInit(anonInvitesFile, anonInvitesOnServer, random);
-                return await own_params_1.OwnSendingParams.makeAndInit(await fs.writableFile(OWN_PARAMS_FILE), anonInvites);
-            })
-        ]);
-        await fs.close();
-        return new SendingParamsHolder(paramsFromOthers, ownParams);
-    }
-    async close() {
-        await this.ownParams.close();
-        await this.paramsFromOthers.close();
+async function makeSendingParamsHolder(fs, anonInvitesOnServer, random) {
+    const [otherSides, thisSide] = await Promise.all([
+        (0, params_from_others_1.makeParamsFromOthers)(fs, PARAMS_FROM_OTHERS_FILE),
+        (0, own_params_1.makeOwnSendingParams)(fs, OWN_PARAMS_FILE, await (0, invitations_anon_1.makeAnonymousInvites)(fs, ANONYM_INVITES_FILE, anonInvitesOnServer, random))
+    ]);
+    async function close() {
+        await thisSide.close();
+        await otherSides.close();
     }
+    return {
+        thisSide,
+        otherSides,
+        close
+    };
 }
-exports.SendingParamsHolder = SendingParamsHolder;
-Object.freeze(SendingParamsHolder.prototype);
-Object.freeze(SendingParamsHolder);
 Object.freeze(exports);

package/build/core/asmail/sending-params/invitations-anon.d.ts

@@ -1,37 +1,13 @@
 import { ParamOnServer } from '../../../lib-client/asmail/service-config';
 import { AsyncRNG } from '../../../lib-common/rng-def';
-type WritableFile = web3n.files.WritableFile;
-interface InvitesJSON {
-    invites: {
-        [invite: string]: {
-            label: string;
-            msgMaxSize: number;
-        };
-    };
-}
-export declare class AnonymousInvites {
-    private readonly anonInvitesOnServer;
-    private readonly random;
-    private invites;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<AnonymousInvites>;
-    private onFileEvent;
-    protected setFromJSON(json: InvitesJSON): void;
-    private toFileJSON;
-    private persist;
-    private absorbRemoteChanges;
-    private toServerParam;
-    private toServiceJSON;
-    private syncServiceSetting;
-    getAll(): Map<string, {
+type WritableFS = web3n.files.WritableFS;
+export type AnonymousInvites = Awaited<ReturnType<typeof makeAnonymousInvites>>;
+export declare function makeAnonymousInvites(fs: WritableFS, fileName: string, anonInvitesOnServer: ParamOnServer<'anon-sender/invites'>, random: AsyncRNG): Promise<{
+    create: (label: string, msgMaxSize: number) => Promise<string>;
+    getAll: () => Map<string, {
         invite: string;
         msgMaxSize: number;
     }>;
-    create(label: string, msgMaxSize: number): Promise<string>;
-    private generateNewRandomInvite;
-    private findByLabel;
-    setMsgMaxSize(label: string, msgMaxSize: number): Promise<void>;
-    close(): Promise<void>;
-}
+    close: () => Promise<void>;
+}>;
 export {};

package/build/core/asmail/sending-params/invitations-anon.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 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,160 +16,110 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnonymousInvites = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
-const json_utils_1 = require("../../../lib-common/json-utils");
+exports.makeAnonymousInvites = makeAnonymousInvites;
 const rng_def_1 = require("../../../lib-common/rng-def");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const INVITE_TOKEN_LEN = 40;
-class AnonymousInvites {
-    constructor(anonInvitesOnServer, random) {
-        this.anonInvitesOnServer = anonInvitesOnServer;
-        this.random = random;
-        this.invites = {};
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
-    }
-    static async makeAndInit(file, anonInvitesOnServer, random) {
-        const anonInvites = new AnonymousInvites(anonInvitesOnServer, random);
-        await anonInvites.fileProc.start(file, () => anonInvites.toFileJSON());
-        // XXX these are part of proper syncing logic
-        // await anonInvites.absorbRemoteChanges();
-        // await anonInvites.syncServiceSetting();
-        return anonInvites;
-    }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+async function makeAnonymousInvites(fs, fileName, anonInvitesOnServer, random) {
+    const { file: invitesFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON({ invites: {} }));
+    function parseInvitesFromJSON(json) {
+        const invites = json.invites;
+        if (invites || (typeof invites === 'object')) {
+            return invites;
         }
-        switch (ev.type) {
-            case 'file-change':
-                await this.fileProc.order.startOrChain(() => this.absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with parameter "anon-sender/invites"`);
-            default:
-                return;
+        else {
+            return {};
         }
     }
-    setFromJSON(json) {
-        this.invites = json.invites;
-    }
-    toFileJSON() {
-        return {
-            invites: this.invites
-        };
+    let invites = parseInvitesFromJSON(await invitesFile.readJSON());
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await invitesFile.v.readJSON();
+            if (version === newVersion) {
+                invites = parseInvitesFromJSON(json);
+            }
+        });
     }
-    async persist() {
-        await this.fileProc.order.startOrChain(async () => {
-            await this.anonInvitesOnServer.setOnServer(this.toServerParam());
-            await this.fileProc.save(this.toFileJSON(), false);
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            const { remote, state } = await invitesFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
+                return;
+            }
+            const onRemote = (await invitesFile.v.readJSON({ remoteVersion: remote.latest })).json;
+            const numOfInvitesOnRemote = Object.keys(onRemote.invites).length;
+            const numOfCurrentInvites = Object.keys(invites).length;
+            const joined = { ...onRemote.invites, ...invites };
+            const numOfJoined = Object.keys(joined).length;
+            if ((numOfCurrentInvites === numOfInvitesOnRemote) && (numOfCurrentInvites === numOfJoined)) {
+                await invitesFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+            else {
+                invites = joined;
+                await invitesFile.writeJSON({ invites });
+                await invitesFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+                await anonInvitesOnServer.setOnServer(invitesToServerParamForm(invites));
+            }
         });
     }
-    async absorbRemoteChanges() {
-        // XXX
-        //  - check for changes: what is needed here from fileProc, and what is
-        //    generic in absorbing remote changes to refactor it into JsonFileProc
-        //  - absorb and sync, if needed: what can be in JsonFileProc
-        // Code from pre-v.sync:
-        // const { json } = await this.fileProc.get();
-        // this.setFromJSON(json);
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(invitesFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    async function persist() {
+        await anonInvitesOnServer.setOnServer(invitesToServerParamForm(invites));
+        await invitesFile.writeJSON({ invites });
+        triggerUpload();
     }
-    toServerParam() {
+    function invitesToServerParamForm(invites) {
         const serverParam = {};
-        for (const [invite, { msgMaxSize }] of Object.entries(this.invites)) {
+        for (const [invite, { msgMaxSize }] of Object.entries(invites)) {
             serverParam[invite] = msgMaxSize;
         }
         return serverParam;
     }
-    toServiceJSON() {
-        const serverJSON = {};
-        Object.entries(this.invites)
-            .forEach(([invite, params]) => {
-            serverJSON[invite] = params.msgMaxSize;
-        });
-        return serverJSON;
-    }
-    async syncServiceSetting(rethrowConnectExc = false) {
-        // XXX we may have the following bug here:
-        // Device with older version of param gets to this point, and sets older
-        // value.
-        // To protect aginst this case, absorbing from file must ensure highest
-        // synced version is read.
-        try {
-            const infoOnServer = await this.anonInvitesOnServer.getFromServer()
-                .catch((exc) => {
-                if (exc.type === 'connect') {
-                    return;
-                }
-                else {
-                    throw exc;
-                }
-            });
-            const currentVal = this.toServiceJSON();
-            if (!(0, json_utils_1.deepEqual)(infoOnServer, currentVal)) {
-                await this.anonInvitesOnServer.setOnServer(currentVal);
-            }
-        }
-        catch (exc) {
-            if (!rethrowConnectExc
-                && (exc.type === 'connect')) {
-                return;
-            }
-            throw exc;
-        }
-    }
-    getAll() {
+    function getAll() {
         const byLabel = new Map();
-        Object.entries(this.invites)
+        Object.entries(invites)
             .forEach(([invite, params]) => {
             byLabel.set(params.label, { invite, msgMaxSize: params.msgMaxSize });
         });
         return byLabel;
     }
-    ;
-    async create(label, msgMaxSize) {
-        const existingInvite = this.findByLabel(label);
-        if (existingInvite) {
-            throw new Error(`Anonymous sender invite already exists with label ${label}`);
-        }
-        const invite = await this.generateNewRandomInvite();
-        this.invites[invite] = { label, msgMaxSize };
-        try {
-            await this.persist();
-            return invite;
-        }
-        catch (exc) {
-            delete this.invites[invite];
-            throw exc;
-        }
+    function create(label, msgMaxSize) {
+        return changeProc.startOrChain(async () => {
+            const existingInvite = findByLabel(label);
+            if (existingInvite) {
+                throw new Error(`Anonymous sender invite already exists with label ${label}`);
+            }
+            const invite = await generateNewRandomInvite();
+            invites[invite] = { label, msgMaxSize };
+            try {
+                await persist();
+                return invite;
+            }
+            catch (exc) {
+                delete invites[invite];
+                throw exc;
+            }
+        });
     }
-    ;
-    async generateNewRandomInvite() {
+    async function generateNewRandomInvite() {
         let invite;
         do {
-            invite = await (0, rng_def_1.stringOfB64Chars)(INVITE_TOKEN_LEN, this.random);
-        } while (this.invites[invite]);
+            invite = await (0, rng_def_1.stringOfB64Chars)(INVITE_TOKEN_LEN, random);
+        } while (invites[invite]);
         return invite;
     }
-    findByLabel(label) {
-        const found = Object.entries(this.invites)
+    function findByLabel(label) {
+        const found = Object.entries(invites)
             .find(([_, params]) => (params.label === label));
         return (found ? found[0] : undefined);
     }
-    async setMsgMaxSize(label, msgMaxSize) {
-        const invite = this.findByLabel(label);
-        if (!invite) {
-            throw new Error(`There is no anonymous sender invite with label ${label}`);
-        }
-        this.invites[invite].msgMaxSize = msgMaxSize;
-        await this.persist();
-    }
-    ;
-    async close() {
-        await this.fileProc.close();
+    async function close() {
+        stopFileWatching();
     }
+    return {
+        create,
+        getAll,
+        close
+    };
 }
-exports.AnonymousInvites = AnonymousInvites;
-Object.freeze(AnonymousInvites.prototype);
-Object.freeze(AnonymousInvites);
 Object.freeze(exports);

package/build/core/asmail/sending-params/own-params.d.ts

@@ -1,28 +1,8 @@
 import { SendingParamsHolder } from './index';
 import { AnonymousInvites } from './invitations-anon';
-type ExposedFuncs = SendingParamsHolder['thisSide'];
-type WritableFile = web3n.files.WritableFile;
-type FileEvent = web3n.files.FileEvent;
-/**
- * Instance of this class keeps track of sending parameters, which user gives to
- * other correspondents for sending messages back. These parameters may have
- * invitation tokens, and this class uses config service to register tokens on
- * a server.
- */
-export declare class OwnSendingParams {
-    private readonly anonInvites;
-    private readonly params;
-    private defaultParams;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile, anonInvites: AnonymousInvites): Promise<OwnSendingParams>;
-    private setDefaultParams;
-    private toFileJSON;
-    private persist;
-    private absorbChangesFromFile;
-    protected onFileEvent(ev: FileEvent): Promise<void>;
-    getFor: ExposedFuncs['getUpdated'];
-    setAsInUse: ExposedFuncs['setAsUsed'];
-    close(): Promise<void>;
-}
+type WritableFS = web3n.files.WritableFS;
+export type OwnSendingParams = Awaited<ReturnType<typeof makeOwnSendingParams>>;
+export declare function makeOwnSendingParams(fs: WritableFS, fileName: string, anonInvites: AnonymousInvites): Promise<SendingParamsHolder['thisSide'] & {
+    close: () => Promise<void>;
+}>;
 export {};