core-3nweb-client-lib 0.49.5 → 0.49.7

package/build/lib-sqlite-on-3nstorage/for-sqlite.js

@@ -0,0 +1,162 @@
+"use strict";
+/*
+ Copyright (C) 2025 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.optStringAsEmptyTransform = exports.booleanTransform = exports.jsonTransform = exports.optJsonTransform = void 0;
+exports.queryParamsFrom = queryParamsFrom;
+exports.fromQueryResult = fromQueryResult;
+exports.queryParamsFromComplete = queryParamsFromComplete;
+exports.forTableInsert = forTableInsert;
+exports.performTableInsert = performTableInsert;
+exports.selectFromTable = selectFromTable;
+exports.updateInTable = updateInTable;
+exports.setExprFor = setExprFor;
+exports.andEqualExprFor = andEqualExprFor;
+exports.passOmitting = passOmitting;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// @deno-types="../../shared-libs/sqlite-on-3nstorage/index.d.ts"
+// @deno-types="../../shared-libs/sqlite-on-3nstorage/sqljs.d.ts"
+const index_js_1 = require("./index.js");
+function queryParamsFrom(record, transforms, omit) {
+    const params = {};
+    for (const field of Object.keys(record)) {
+        if (omit === null || omit === void 0 ? void 0 : omit.includes(field)) {
+            continue;
+        }
+        const value = record[field];
+        const transform = transforms[field];
+        if (!transform) {
+            throw new Error(`Field ${field} is not present in TransformDefinition object`);
+        }
+        else if (transform === 'as-is') {
+            params[`$${field}`] = value;
+        }
+        else {
+            const { toSQLValue } = transform;
+            params[`$${field}`] = toSQLValue(value);
+        }
+    }
+    return params;
+}
+function fromQueryResult(queryResult, transforms) {
+    const records = (0, index_js_1.objectFromQueryExecResult)(queryResult);
+    const objs = [];
+    for (const record of records) {
+        const obj = {};
+        for (const field of Object.keys(record)) {
+            const transform = transforms[field];
+            if (!transform || (transform === 'as-is')) {
+                obj[field] = record[field];
+            }
+            else {
+                const { fromSQLValue } = transform;
+                obj[field] = fromSQLValue(record[field]);
+            }
+        }
+        objs.push(obj);
+    }
+    return objs;
+}
+function queryParamsFromComplete(record, transforms) {
+    const params = queryParamsFrom(record, transforms);
+    if (Object.keys(params).length < Object.keys(transforms).length) {
+        throw new Error(`Not all fields are present in the record`);
+    }
+    return params;
+}
+function forTableInsert(record, transforms) {
+    const insertParams = queryParamsFromComplete(record, transforms);
+    const columns = [];
+    const values = [];
+    for (const field of Object.keys(record)) {
+        const paramField = `$${field}`;
+        if (insertParams[paramField] === undefined) {
+            throw new Error(`Mismatch in expected parameters: ${paramField} is missing`);
+        }
+        else {
+            columns.push(field);
+            values.push(paramField);
+        }
+    }
+    return {
+        insertParams,
+        orderedColumns: columns.join(', '),
+        orderedValues: values.join(', ')
+    };
+}
+function performTableInsert(db, tabName, record, transforms) {
+    const { insertParams, orderedColumns, orderedValues } = forTableInsert(record, transforms);
+    db.exec(`INSERT INTO ${tabName} (${orderedColumns}) VALUES (${orderedValues})`, insertParams);
+}
+function selectFromTable(db, tabName, selectColumns, selectWith, transforms) {
+    const whereParams = queryParamsFrom(selectWith, transforms);
+    const whereClause = andEqualExprFor(whereParams);
+    const [sqlValue] = db.exec(`SELECT ${Array.isArray(selectColumns) ? selectColumns.join(', ') : '*'} FROM ${tabName} WHERE ${whereClause}`, whereParams);
+    return sqlValue ? fromQueryResult(sqlValue, transforms) : undefined;
+}
+function updateInTable(db, tabName, valuesToSet, updateWith, transforms) {
+    const whereParams = queryParamsFrom(updateWith, transforms);
+    const whereClause = andEqualExprFor(whereParams);
+    const setParams = queryParamsFrom(valuesToSet, transforms);
+    const setExpr = setExprFor(setParams);
+    db.exec(`UPDATE ${tabName} SET ${setExpr} WHERE ${whereClause}`, { ...whereParams, ...setParams });
+}
+function setExprFor(params, omit) {
+    const setPairs = [];
+    for (const paramField of Object.keys(params)) {
+        const field = paramField.substring(1);
+        if (!(omit === null || omit === void 0 ? void 0 : omit.includes(field))) {
+            setPairs.push(`${field}=${paramField}`);
+        }
+    }
+    return setPairs.join(', ');
+}
+function andEqualExprFor(params, omit) {
+    const pairs = [];
+    for (const paramField of Object.keys(params)) {
+        const field = paramField.substring(1);
+        if (!(omit === null || omit === void 0 ? void 0 : omit.includes(field))) {
+            pairs.push(`${field}=${paramField}`);
+        }
+    }
+    return pairs.join(' AND ');
+}
+exports.optJsonTransform = {
+    toSQLValue: (v) => (v ? JSON.stringify(v) : null),
+    fromSQLValue: (sv) => (sv ? JSON.parse(sv) : null)
+};
+exports.jsonTransform = {
+    toSQLValue: (v) => JSON.stringify(v),
+    fromSQLValue: (sv) => JSON.parse(sv)
+};
+exports.booleanTransform = {
+    toSQLValue: (b) => (b ? 1 : 0),
+    fromSQLValue: (flag) => ((flag === 1) ? true : false)
+};
+exports.optStringAsEmptyTransform = {
+    toSQLValue: (s) => (s ? s : ''),
+    fromSQLValue: (s) => (s ? s : '')
+};
+function passOmitting(o, ...omitted) {
+    const copy = {};
+    for (const [field, value] of Object.entries(o)) {
+        if (!omitted.includes(field)) {
+            copy[field] = value;
+        }
+    }
+    return copy;
+}

package/build/lib-sqlite-on-3nstorage/index.d.ts

@@ -4,20 +4,24 @@ export type Database = DBClass;
 export type BindParams = QueryParams;
 export type QueryExecResult = QueryResult;
 type WritableFile = web3n.files.WritableFile;
-export interface SaveOpts {
-    skipUpload?: boolean;
-}
+type WritableFileSyncAPI = web3n.files.WritableFileSyncAPI;
 export declare abstract class SQLiteOn3NStorage {
     protected readonly database: Database;
     protected readonly file: WritableFile;
     protected readonly syncProc: SingleProc;
     protected constructor(database: Database, file: WritableFile);
-    static makeAndStart(file: WritableFile): Promise<SQLiteOn3NStorage>;
+    static makeSynced(file: WritableFile, startWithFileContent?: boolean): Promise<SQLiteOnSyncedFS>;
     private start;
-    saveToFile(opts?: SaveOpts): Promise<void>;
+    saveToFile(): Promise<void>;
     get db(): Database;
     sync<T>(action: Action<T>): Promise<T>;
     listTables(): string[];
+    makeCopyIn(file: WritableFile): Promise<SQLiteOn3NStorage>;
+}
+export declare class SQLiteOnSyncedFS extends SQLiteOn3NStorage {
+    constructor(db: Database, file: WritableFile);
+    get dbFile(): WritableFile;
+    get dbFileSync(): WritableFileSyncAPI;
 }
 export declare function objectFromQueryExecResult<T>(sqlResult: QueryExecResult): Array<T>;
 type KeyedInfo<T> = {
@@ -26,11 +30,20 @@ type KeyedInfo<T> = {
 export declare class TableColumnsAndParams<EntryType extends object> {
     readonly name: string;
     private readonly columnDefs;
+    /**
+     * c is column name, just column name
+     */
     readonly c: KeyedInfo<EntryType>;
     readonly cReversed: {
         [colName: string]: keyof EntryType;
     };
+    /**
+     * p is parameter for column
+     */
     readonly p: KeyedInfo<EntryType>;
+    /**
+     * q is a qualified column name with table name
+     */
     readonly q: KeyedInfo<EntryType>;
     readonly columnsCreateSection: string;
     constructor(name: string, columnDefs: {

package/build/lib-sqlite-on-3nstorage/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2022 - 2023 3NSoft Inc.
+ Copyright (C) 2022 - 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
@@ -16,7 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableColumnsAndParams = exports.SQLiteOn3NStorage = void 0;
+exports.TableColumnsAndParams = exports.SQLiteOnSyncedFS = exports.SQLiteOn3NStorage = void 0;
 exports.objectFromQueryExecResult = objectFromQueryExecResult;
 const sqljs_js_1 = require("./sqljs.js");
 const synced_js_1 = require("./synced.js");
@@ -26,28 +26,35 @@ class SQLiteOn3NStorage {
         this.file = file;
         this.syncProc = new synced_js_1.SingleProc();
     }
-    static async makeAndStart(file) {
+    // static async makeAndStart(file: WritableFile): Promise<SQLiteOn3NStorage> {
+    // 	const SQL = await initSqlJs(true);
+    // 	const fileContent = await readFileContent(file);
+    // 	const db = new SQL.Database(fileContent);
+    // 	let sqlite: SQLiteOn3NStorage;
+    // 	if (file.v?.sync) {
+    // 		sqlite = new SQLiteOnSyncedFS(db, file);
+    // 	} else if (file.v) {
+    // 		sqlite = new SQLiteOnLocalFS(db, file);
+    // 	} else {
+    // 		sqlite = new SQLiteOnDeviceFS(db, file);
+    // 	}
+    // 	await sqlite.start();
+    // 	return sqlite;
+    // }
+    static async makeSynced(file, startWithFileContent = true) {
         var _a;
-        const SQL = await (0, sqljs_js_1.default)(true);
-        const fileContent = await readFileContent(file);
-        const db = new SQL.Database(fileContent);
-        let sqlite;
-        if ((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync) {
-            sqlite = new SQLiteOnSyncedFS(db, file);
+        if (!((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync)) {
+            throw new TypeError(`Expected synced file to make synced db`);
         }
-        else if (file.v) {
-            sqlite = new SQLiteOnLocalFS(db, file);
-        }
-        else {
-            sqlite = new SQLiteOnDeviceFS(db, file);
-        }
-        await sqlite.start();
-        return sqlite;
+        const SQL = await (0, sqljs_js_1.default)(true);
+        const initialContent = startWithFileContent ? (await readFileContent(file)) : undefined;
+        const db = new SQL.Database(initialContent);
+        return new SQLiteOnSyncedFS(db, file);
     }
     async start() {
         // XXX add listening process(es)
     }
-    async saveToFile(opts) {
+    async saveToFile() {
         await this.syncProc.startOrChain(async () => {
             const dbFileContent = this.database.export();
             await this.file.writeBytes(dbFileContent);
@@ -65,6 +72,24 @@ class SQLiteOn3NStorage {
             result[0].values.map(row => row[0]) :
             []);
     }
+    async makeCopyIn(file) {
+        var _a;
+        const SQL = await (0, sqljs_js_1.default)(true);
+        const fileContent = this.database.export();
+        const db = new SQL.Database(fileContent);
+        let sqlite;
+        if ((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync) {
+            sqlite = new SQLiteOnSyncedFS(db, file);
+        }
+        else if (file.v) {
+            sqlite = new SQLiteOnLocalFS(db, file);
+        }
+        else {
+            sqlite = new SQLiteOnDeviceFS(db, file);
+        }
+        await sqlite.start();
+        return sqlite;
+    }
 }
 exports.SQLiteOn3NStorage = SQLiteOn3NStorage;
 Object.freeze(SQLiteOn3NStorage.prototype);
@@ -74,16 +99,14 @@ class SQLiteOnSyncedFS extends SQLiteOn3NStorage {
         super(db, file);
         Object.seal(this);
     }
-    async saveToFile(opts) {
-        await super.saveToFile();
-        if (opts === null || opts === void 0 ? void 0 : opts.skipUpload) {
-            return;
-        }
-        else {
-            await this.file.v.sync.upload();
-        }
+    get dbFile() {
+        return this.file;
+    }
+    get dbFileSync() {
+        return this.file.v.sync;
     }
 }
+exports.SQLiteOnSyncedFS = SQLiteOnSyncedFS;
 Object.freeze(SQLiteOnSyncedFS.prototype);
 Object.freeze(SQLiteOnSyncedFS);
 class SQLiteOnLocalFS extends SQLiteOn3NStorage {

package/build/tests/caps-api/file-sink-checks/splice.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020, 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
@@ -19,6 +19,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.specs = void 0;
 const random_node_1 = require("../../../lib-common-on-node/random-node");
 const bytes_equal_1 = require("../../libs-for-tests/bytes-equal");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const json_equal_1 = require("../../libs-for-tests/json-equal");
 exports.specs = {
     description: 'gives file sinks, able to splice file content',
     its: []
@@ -119,4 +121,73 @@ it.func = async function (s) {
     expect((0, bytes_equal_1.bytesEqual)(content.subarray(7000), chunk2)).toBe(true);
 };
 exports.specs.its.push(it);
+// XXX enbale this when capturing this bug
+it = {
+    expectation: 'usecase with removing and adding sections of json', disableIn: 'device-fs'
+};
+it.func = async function (s) {
+    const { testFS } = s;
+    const file = 'incremental-file';
+    const COMMA_BYTE = buffer_utils_1.utf8.pack(',');
+    const SQ_BRACKET_BYTE = buffer_utils_1.utf8.pack(']');
+    const completeContent = [
+        {
+            record: {
+                msgId: "F-vo1A4zInEBGq994-e3KvrE9a8QXLcr",
+            }
+        },
+        {
+            record: {
+                msgId: "JYXfEEcg3-iX7UDjG3BU0Jha9DYX_Jt-",
+            }
+        }
+    ];
+    const TEST_XATTR = 'attr-for-test';
+    const attrValue1 = Date.now();
+    const attrValue2 = { comment: 'now json value', ts: Date.now() };
+    // the following splice pattern hit an error, hence seemingly out of the blue use case, but it is an echo
+    // XXX removal of fs.updateXAttrs() call removes error in this situation
+    console.log(`p 1`);
+    await testFS.writeTxtFile(file, `[]`);
+    console.log(`p 2`);
+    let sink = await testFS.getByteSink(file, { truncate: false });
+    console.log(`p 2.1`);
+    await sink.splice(1, 1);
+    console.log(`p 2.2`);
+    let bytes = buffer_utils_1.utf8.pack(JSON.stringify(completeContent[0]));
+    console.log(`p 2.3`);
+    await sink.splice(1, 0, bytes);
+    console.log(`p 2.4`);
+    await sink.splice(1 + bytes.length, 0, SQ_BRACKET_BYTE);
+    console.log(`p 2.5`);
+    await sink.done();
+    console.log(`p 2.6`);
+    await testFS.updateXAttrs(file, { set: { [TEST_XATTR]: attrValue1 } });
+    console.log(`p 3`);
+    globalThis.log$ = true;
+    sink = await testFS.getByteSink(file, { truncate: false });
+    console.log(`p 3.1 -------- getting size`);
+    const len = await sink.getSize();
+    console.log(`p 3.2 ------------ replacing one last byte in content, \n layout`, await sink.showLayout());
+    await sink.splice(len - 1, 1, COMMA_BYTE);
+    // 	await sink.splice(len-1, 1);
+    // console.log(`p 3.2+ ---------------------------------- replacing one last byte in content, \n layout`, await sink.showLayout());
+    // 	await sink.splice(len-1, 0, COMMA_BYTE);
+    // await sink.splice(len-1, 1, utf8.pack(',  '));
+    console.log(`p 3.3 ----------- writing content after last replaced byte, \n layout`, await sink.showLayout());
+    bytes = buffer_utils_1.utf8.pack(JSON.stringify(completeContent[1]));
+    await sink.splice(len, 0, bytes);
+    console.log(`p 3.4 -------- turning logging off, \n layout`, await sink.showLayout());
+    globalThis.log$ = false;
+    await sink.splice(len + bytes.length, 0, SQ_BRACKET_BYTE);
+    console.log(`p 3.5, \n layout`, await sink.showLayout());
+    const attrWrite = testFS.updateXAttrs(file, { set: { [TEST_XATTR]: attrValue2 } });
+    console.log(`p 3.6`);
+    await sink.done();
+    await attrWrite;
+    console.log(`p 4`);
+    expect((0, json_equal_1.deepEqual)(completeContent, await testFS.readJSONFile(file))).toBeTrue();
+    console.log(`p 5`);
+};
+// specs.its.push(it);
 Object.freeze(exports);

package/build/tests/caps-api/fs-checks/sync-on-one-dev/upload.js

@@ -161,10 +161,36 @@ it.func = async function (s) {
     await testFS.v.sync.upload(folder);
     syncStatus = await testFS.v.sync.status(folder, true);
     expect(syncStatus.state).toBe('synced');
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
     // note again that upload is not uploading children
     syncStatus = await testFS.v.sync.status(childPath, true);
     expect(syncStatus.state).toBe('unsynced');
-    expect(syncStatus.existsInSyncedParent).toBeTruthy();
+    expect(syncStatus.existsInSyncedParent).toBeTrue();
+    const subFS = await testFS.writableSubRoot(folder);
+    syncStatus = await subFS.v.sync.status('', true);
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
+    await testFS.v.sync.upload('');
+    syncStatus = await testFS.v.sync.status(folder, true);
+    expect(syncStatus.existsInSyncedParent).toBeTrue();
+    syncStatus = await subFS.v.sync.status('', true);
+    expect(syncStatus.existsInSyncedParent).toBeTrue();
+    const childFolder = `child-folder`;
+    await subFS.makeFolder(childFolder);
+    // child never uploaded at this point
+    await subFS.v.sync.upload('').then(() => fail(`upload of folder must fail with child that was never uploaded`), (exc) => {
+        expect(exc.type).toBe('fs-sync');
+        expect(exc.childNeverUploaded).toBeTrue();
+        expect(exc.childName).toBe(childFolder);
+    });
+    // uploading child, but it isn't yet in synced version of parent
+    await subFS.v.sync.upload(childFolder);
+    syncStatus = await subFS.v.sync.status(childFolder);
+    expect(syncStatus.state).toBe('synced');
+    expect(syncStatus.existsInSyncedParent).toBeFalsy();
+    // syncing parent makes child findable from upper synced point, and sync UX guarantees can be provided
+    await subFS.v.sync.upload('');
+    syncStatus = await subFS.v.sync.status(childFolder);
+    expect(syncStatus.existsInSyncedParent).toBeTrue();
 };
 exports.specs.its.push(it);
 it = { expectation: `should do own concurrently` };

package/build/tests/caps-api/fs-checks/sync-with-two-devs/update-propagation.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2022, 2025 3NSoft Inc.
+ Copyright (C) 2022, 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
@@ -23,6 +23,7 @@ const random_node_1 = require("../../../../lib-common-on-node/random-node");
 const bytes_equal_1 = require("../../../libs-for-tests/bytes-equal");
 const json_equal_1 = require("../../../libs-for-tests/json-equal");
 const test_utils_1 = require("../test-utils");
+const lodash_1 = require("lodash");
 exports.specs = {
     description: '--',
     its: []
@@ -141,7 +142,7 @@ it.func = async function ({ dev1FS, dev2FS }) {
     await fs1.v.sync.upload(file);
     let fileEv = await fileEventAt2;
     expect(fileEv.type).toBe('remote-change');
-    expect((0, json_equal_1.deepEqual)(fileEv.syncStatus, await fs2.v.sync.status(file))).toBeTrue();
+    expect((0, json_equal_1.deepEqual)(fileEv.syncStatus, (0, lodash_1.omit)(await fs2.v.sync.status(file), 'existsInSyncedParent', 'uploading'))).toBeTrue();
     expect(await fs2.v.sync.isRemoteVersionOnDisk(file, fileEv.newRemoteVersion)).toBe('none');
     let events = collectFileDownloadEvents(fs2, file);
     startedDownload = await fs2.v.sync.startDownload(file, fileEv.newRemoteVersion);
@@ -198,6 +199,10 @@ it.func = async function ({ dev1FS, dev2FS }) {
             }
         }
     ];
+    // XXX enable attr writes, when sink's bug is fixed
+    // const TEST_XATTR = 'attr-for-test';
+    // const attrValue1 = Date.now();
+    // const attrValue2 = { comment: 'now json value', ts: Date.now() };
     // we do this file writing and uploading, cause this pattern hit an error,
     // hence, we add this test with this seemingly out of the blue setup
     await fs1.writeTxtFile(file, `[]`);
@@ -209,6 +214,7 @@ it.func = async function ({ dev1FS, dev2FS }) {
     await sink.splice(1, 0, bytes);
     await sink.splice(1 + bytes.length, 0, SQ_BRACKET_BYTE);
     await sink.done();
+    // await fs1.updateXAttrs(file, { set: { [TEST_XATTR]: attrValue1 } });
     await fs1.v.sync.upload(file);
     sink = await fs1.getByteSink(file, { truncate: false });
     const len = await sink.getSize();
@@ -216,14 +222,17 @@ it.func = async function ({ dev1FS, dev2FS }) {
     bytes = buffer_utils_1.utf8.pack(JSON.stringify(completeContent[1]));
     await sink.splice(len, 0, bytes);
     await sink.splice(len + bytes.length, 0, SQ_BRACKET_BYTE);
+    // const attrWrite = fs1.updateXAttrs(file, { set: { [TEST_XATTR]: attrValue2 } });
     await sink.done();
+    // await attrWrite;
     expect((0, json_equal_1.deepEqual)(completeContent, await fs1.readJSONFile(file))).toBeTrue();
     await fs1.v.sync.upload(file);
     // and on the second device
     expect((await fs2.v.sync.status('')).state).toBe('behind');
     await fs2.v.sync.adoptRemote('');
     expect((await fs2.v.sync.status(file)).state).toBe('synced');
-    expect((0, json_equal_1.deepEqual)(completeContent, await fs2.readJSONFile(file))).toBeTrue();
+    expect((0, json_equal_1.deepEqual)(completeContent, await fs2.readJSONFile(file))).withContext(`contents of files should be same`).toBeTrue();
+    // expect(deepEqual(attrValue2, await fs2.getXAttr(file, TEST_XATTR))).withContext(`content of attr should be same`).toBeTrue();
 };
 exports.specs.its.push(it);
 Object.freeze(exports);

package/build/tests/computer.3nweb.core/inbox/msg-indexing.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright 2022 3NSoft Inc.
+ Copyright 2022, 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
@@ -17,7 +17,6 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 const msg_indexing_1 = require("../../../core/asmail/inbox/msg-indexing");
-// import { MsgKeyInfo } from "../core/asmail/keyring";
 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");
@@ -91,7 +90,7 @@ const msgs = [
         }
     }
 ];
-xdescribe(`Inbox MsgIndex`, () => {
+describe(`Inbox MsgIndex`, () => {
     const baseSetup = (0, setups_1.setupWithUsers)();
     const testFolder = `inbox-indexing-test`;
     let dev1Index;
@@ -100,7 +99,7 @@ xdescribe(`Inbox MsgIndex`, () => {
         await setupDevsAndFSs(baseSetup);
     }, 20000);
     beforeEach(async () => {
-        dev1Index = await msg_indexing_1.MsgIndex.make(setup.dev1FS());
+        dev1Index = await (0, msg_indexing_1.makeMsgIndex)(setup.dev1FS(), setup.dev1LocalFS(), async (err, msg) => console.error(msg, err));
     });
     (0, jasmine_utils_1.afterEachCond)(async () => {
         if (!setup.isUp) {
@@ -125,9 +124,11 @@ xdescribe(`Inbox MsgIndex`, () => {
         await dev1Index.remove(m0.m.msgId);
         lst = await dev1Index.listMsgs(undefined);
         expect(lst.length).toBe(1);
-        const keyInfo = await dev1Index.getKeyFor(m1.m.msgId, m1.m.deliveryTS);
-        expect((0, bytes_equal_1.bytesEqual)(keyInfo.msgKey, m1.k.key))
-            .toBeTrue();
+        let keyInfo = await dev1Index.getKeyFor(m1.m.msgId, m1.m.deliveryTS);
+        expect((0, bytes_equal_1.bytesEqual)(keyInfo.msgKey, m1.k.key)).toBeTrue();
+        // getting removed / non-existing message
+        keyInfo = await dev1Index.getKeyFor(m0.m.msgId, m0.m.deliveryTS);
+        expect(keyInfo).toBeUndefined();
     }, undefined, setup);
     (0, jasmine_utils_1.itCond)(`work with race conditions on different devices`, async () => {
         for (const m of msgs.slice(0, 2)) {
@@ -135,11 +136,14 @@ xdescribe(`Inbox MsgIndex`, () => {
         }
         // sleep to allow time for propagation to dev2
         await (0, sleep_1.sleep)(100);
-        const dev2Index = await msg_indexing_1.MsgIndex.make(setup.dev2FS());
+        const dev2Index = await (0, msg_indexing_1.makeMsgIndex)(setup.dev2FS(), setup.dev2LocalFS(), async (err, msg) => console.error(msg, err));
+        await (0, sleep_1.sleep)(100);
         let lst = await dev2Index.listMsgs(undefined);
-        expect(lst.length)
-            .withContext(``)
-            .toBe(2);
+        expect(lst.length).withContext(`messages at a start of 2nd device`).toBe(2);
+        await dev1Index.add(msgs[2].m, msgs[2].k);
+        await (0, sleep_1.sleep)(100);
+        lst = await dev2Index.listMsgs(undefined);
+        expect(lst.length).withContext(`added message on the 1st device should show up on the 2nd`).toBe(3);
         dev2Index.stopSyncing();
-    });
+    }, 10000);
 });