core-3nweb-client-lib 0.26.1 → 0.27.3

package/build/lib-client/3nstorage/xsp-fs/folder-node.js

@@ -24,9 +24,11 @@ exports.FolderNode = void 0;
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const file_1 = require("../../../lib-common/exceptions/file");
 const error_1 = require("../../../lib-common/exceptions/error");
+const common_1 = require("./common");
 const node_in_fs_1 = require("./node-in-fs");
 const file_node_1 = require("./file-node");
 const link_node_1 = require("./link-node");
+const exceptions_1 = require("../exceptions");
 const deferred_1 = require("../../../lib-common/processes/deferred");
 const json_utils_1 = require("../../../lib-common/json-utils");
 const xsp_files_1 = require("xsp-files");
@@ -34,9 +36,11 @@ const random = require("../../../lib-common/random-node");
 const folder_node_serialization_1 = require("./folder-node-serialization");
 const attrs_1 = require("./attrs");
 const node_persistence_1 = require("./node-persistence");
+const assert_1 = require("../../../lib-common/assert");
+const for_arrays_1 = require("../util/for-arrays");
 function jsonToInfoAndAttrs(json) {
     const folderInfo = {
-        nodes: json_utils_1.copy(json.nodes)
+        nodes: (0, json_utils_1.copy)(json.nodes)
     };
     for (const node of Object.values(folderInfo.nodes)) {
         node.key = buffer_utils_1.base64.open(node.key);
@@ -51,14 +55,22 @@ class FolderPersistance extends node_persistence_1.NodePersistance {
         Object.seal(this);
     }
     async write(folderInfo, version, attrs, xattrs) {
-        const bytes = folder_node_serialization_1.serializeFolderInfo(folderInfo);
+        const bytes = (0, folder_node_serialization_1.serializeFolderInfo)(folderInfo);
         return this.writeWhole(bytes, version, attrs, xattrs);
     }
     async read(src) {
         const { content, xattrs, attrs } = await this.readAll(src);
-        const folderInfo = folder_node_serialization_1.parseFolderInfo(content);
+        const folderInfo = (0, folder_node_serialization_1.parseFolderInfo)(content);
         return { folderInfo, xattrs, attrs: attrs_1.CommonAttrs.fromAttrs(attrs) };
     }
+    static async readFolderContent(objId, key, src, cryptor) {
+        if (objId === null) {
+            throw new Error("Missing objId for non-root folder");
+        }
+        const zNonce = (0, xsp_files_1.idToHeaderNonce)(objId);
+        const { folderInfo } = await (new FolderPersistance(zNonce, key, cryptor)).read(src);
+        return folderInfo;
+    }
 }
 Object.freeze(FolderPersistance.prototype);
 Object.freeze(FolderPersistance);
@@ -77,18 +89,11 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     constructor(storage, name, objId, zNonce, version, parentId, key, setNewAttrs) {
         super(storage, 'folder', name, objId, version, parentId);
         this.currentState = { nodes: {} };
-        if (!name && (objId || parentId)) {
-            throw new Error("Root folder must " +
-                "have both objId and parent as nulls.");
+        if (name === undefined) {
+            (0, assert_1.assert)(!objId && !parentId, `Root folder must have both objId and parent as nulls.`);
         }
         else if (objId === null) {
-            new Error("Missing objId for non-root folder");
-        }
-        if (!zNonce) {
-            if (!objId) {
-                throw new Error(`Missing object id for folder, when zeroth nonce is not given`);
-            }
-            zNonce = xsp_files_1.idToHeaderNonce(objId);
+            throw new Error("Missing objId for non-root folder");
         }
         this.crypto = new FolderPersistance(zNonce, key, storage.cryptor);
         if (setNewAttrs) {
@@ -104,20 +109,21 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return rf;
     }
     static async rootFromObjBytes(storage, name, objId, src, key) {
-        let zNonce = undefined;
-        if (!objId) {
-            const header = await src.readHeader();
-            zNonce = xsp_files_1.calculateNonce(header.subarray(0, xsp_files_1.NONCE_LENGTH), -src.version);
-        }
-        const rf = await FolderNode.readNodeFromObjBytes(storage, name, objId, zNonce, src, key);
+        const rf = await FolderNode.readNodeFromObjBytes(storage, name, objId, src, key);
         rf.storage.nodes.set(rf);
         return rf;
     }
-    static async readNodeFromObjBytes(storage, name, objId, zNonce, src, key) {
+    static async readNodeFromObjBytes(storage, name, objId, src, key) {
+        let zNonce;
+        if (objId) {
+            zNonce = (0, xsp_files_1.idToHeaderNonce)(objId);
+        }
+        else {
+            const header = await src.readHeader();
+            zNonce = (0, xsp_files_1.calculateNonce)(header.subarray(0, xsp_files_1.NONCE_LENGTH), -src.version);
+        }
         const rf = new FolderNode(storage, name, objId, zNonce, src.version, undefined, key, false);
-        const { folderInfo, attrs, xattrs } = await rf.crypto.read(src);
-        rf.currentState = folderInfo;
-        rf.setUpdatedParams(src.version, attrs, xattrs);
+        await rf.setCurrentStateFrom(src);
         return rf;
     }
     static async rootFromLinkParams(storage, params) {
@@ -132,38 +138,112 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             existingNode.crypto.compareKey(params.fKey);
             return existingNode;
         }
-        const src = await storage.getObj(params.objId);
+        const src = await storage.getObjSrc(params.objId);
         const key = buffer_utils_1.base64.open(params.fKey);
         return FolderNode.rootFromObjBytes(storage, params.folderName, params.objId, src, key);
     }
     static rootFromJSON(storage, name, folderJson) {
-        const rf = new FolderNode(storage, name, 'readonly-root', EMPTY_ARR, 0, undefined, undefined, false);
+        const rf = new FolderNode(storage, name, 'readonly-root', EMPTY_ARR, 0, undefined, EMPTY_ARR, false);
         const { folderInfo, attrs, xattrs } = jsonToInfoAndAttrs(folderJson);
         rf.currentState = folderInfo;
         rf.setUpdatedParams(0, attrs, xattrs);
         return rf;
     }
-    list() {
-        const names = Object.keys(this.currentState.nodes);
-        const lst = new Array(names.length);
-        for (let i = 0; i < names.length; i += 1) {
-            const entity = this.currentState.nodes[names[i]];
-            const info = { name: entity.name };
-            if (entity.isFolder) {
-                info.isFolder = true;
-            }
-            else if (entity.isFile) {
-                info.isFile = true;
+    async setCurrentStateFrom(src) {
+        const { folderInfo, attrs, xattrs } = await this.crypto.read(src);
+        this.currentState = folderInfo;
+        this.setUpdatedParams(src.version, attrs, xattrs);
+    }
+    async adoptRemote(opts) {
+        const objsToRm = await this.doChange(true, async () => {
+            try {
+                const adopted = await this.syncedStorage().adoptRemote(this.objId, opts);
+                if (!adopted) {
+                    return;
+                }
+                const src = await this.storage.getObjSrc(this.objId, adopted);
+                const originalState = this.currentState;
+                await this.setCurrentStateFrom(src);
+                const newState = this.currentState;
+                const { renamedNodes, addedNodes, removedNodes } = identifyChanges(originalState.nodes, newState.nodes);
+                for (const node of removedNodes) {
+                    const event = {
+                        type: 'entry-removal',
+                        src: 'sync',
+                        path: this.name,
+                        newVersion: this.version,
+                        name: node.name
+                    };
+                    this.broadcastEvent(event, false, node.objId);
+                }
+                for (const node of addedNodes) {
+                    const event = {
+                        type: 'entry-addition',
+                        src: 'sync',
+                        entry: nodeInfoToListingEntry(node),
+                        path: this.name,
+                        newVersion: this.version
+                    };
+                    this.broadcastEvent(event, false, node.objId);
+                }
+                for (const { objId, oldName, newName } of renamedNodes) {
+                    const event = {
+                        type: 'entry-renaming',
+                        src: 'sync',
+                        oldName,
+                        newName,
+                        path: this.name,
+                        newVersion: this.version
+                    };
+                    this.broadcastEvent(event, false, objId);
+                }
+                return removedNodes;
             }
-            else if (entity.isLink) {
-                info.isLink = true;
+            catch (exc) {
+                throw (0, common_1.setPathInExc)(exc, this.name);
             }
-            lst[i] = info;
+        });
+        if (!objsToRm) {
+            return;
+        }
+        for (const objToRm of objsToRm) {
+            const nodeToRm = await this.getOrMakeChildNodeForInfo(objToRm);
+            this.callRemoveObjOn('sync', nodeToRm);
+        }
+    }
+    callRemoveObjOn(src, node) {
+        if (node.type === 'folder') {
+            node.removeFolderObj(src);
         }
+        else {
+            node.removeNonFolderObj(src);
+        }
+    }
+    list() {
+        const lst = Object.values(this.currentState.nodes)
+            .map(nodeInfoToListingEntry);
         return { lst, version: this.version };
     }
-    listFolders() {
-        return Object.keys(this.currentState.nodes).filter(name => !!this.currentState.nodes[name].isFolder);
+    async childExistsInSyncedVersion(childObjId) {
+        const { state, synced } = await this.syncStatus();
+        if (state === 'synced') {
+            return true;
+        }
+        if (!(synced === null || synced === void 0 ? void 0 : synced.latest)) {
+            return false;
+        }
+        const storage = this.syncedStorage();
+        try {
+            const syncedContent = await storage.getObjSrc(this.objId, synced.latest);
+            const { folderInfo } = await this.crypto.read(syncedContent);
+            const childIsInSynced = !!Object.values(folderInfo.nodes)
+                .find(({ objId }) => (objId === childObjId));
+            return childIsInSynced;
+        }
+        catch (exc) {
+            storage.logError(exc, `Exception thrown in checking whether child node's obj is present in synced version.`);
+            return false;
+        }
     }
     getNodeInfo(name, undefOnMissing = false) {
         const fj = this.currentState.nodes[name];
@@ -174,30 +254,12 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             return;
         }
         else {
-            throw file_1.makeFileException(file_1.Code.notFound, name);
+            throw (0, file_1.makeFileException)('notFound', name);
         }
     }
     hasChild(childName, throwIfMissing = false) {
         return !!this.getNodeInfo(childName, !throwIfMissing);
     }
-    /**
-     * @param objId
-     * @return either node (promise for node), or a deferred, which promise has
-     * been registered under a given id, and, therefore, has to be resolved with
-     * node.
-     */
-    getNodeOrArrangePromise(objId) {
-        const { node, nodePromise } = this.storage.nodes.getNodeOrPromise(objId);
-        if (node) {
-            return { nodeOrPromise: node };
-        }
-        if (nodePromise) {
-            return { nodeOrPromise: nodePromise };
-        }
-        const deferred = deferred_1.defer();
-        this.storage.nodes.setPromise(objId, deferred.promise);
-        return { deferred };
-    }
     async getNode(type, name, undefOnMissing = false) {
         const childInfo = this.getNodeInfo(name, undefOnMissing);
         if (!childInfo) {
@@ -205,36 +267,38 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         if (type) {
             if ((type === 'file') && !childInfo.isFile) {
-                throw file_1.makeFileException(file_1.Code.notFile, childInfo.name);
+                throw (0, file_1.makeFileException)('notFile', childInfo.name);
             }
             else if ((type === 'folder') && !childInfo.isFolder) {
-                throw file_1.makeFileException(file_1.Code.notDirectory, childInfo.name);
+                throw (0, file_1.makeFileException)('notDirectory', childInfo.name);
             }
             else if ((type === 'link') && !childInfo.isLink) {
-                throw file_1.makeFileException(file_1.Code.notLink, childInfo.name);
+                throw (0, file_1.makeFileException)('notLink', childInfo.name);
             }
         }
-        const { nodeOrPromise: child, deferred } = this.getNodeOrArrangePromise(childInfo.objId);
-        if (child) {
-            return child;
+        return this.getOrMakeChildNodeForInfo(childInfo);
+    }
+    async getOrMakeChildNodeForInfo(info) {
+        const { node, nodePromise } = this.storage.nodes.getNodeOrPromise(info.objId);
+        if (node) {
+            return node;
+        }
+        if (nodePromise) {
+            return nodePromise;
         }
+        const deferred = (0, deferred_1.defer)();
+        this.storage.nodes.setPromise(info.objId, deferred.promise);
         try {
             let node;
-            if (childInfo.isFile) {
-                node = await file_node_1.FileNode.makeForExisting(this.storage, this.objId, name, childInfo.objId, childInfo.key);
-            }
-            else if (childInfo.isFolder) {
-                const src = await this.storage.getObj(childInfo.objId);
-                // const f = new FolderNode(
-                // 	this.storage, childInfo.name, childInfo.objId, undefined,
-                // 	src.version, this.objId, childInfo.key, false);
-                // const { folderInfo, attrs } = await f.crypto.open(src);
-                // f.currentState = folderInfo;
-                // f.attrs = (attrs ? attrs : AttrsHolder.makeReadonlyForFolder(0));
-                node = await FolderNode.readNodeFromObjBytes(this.storage, childInfo.name, childInfo.objId, undefined, src, childInfo.key);
-            }
-            else if (childInfo.isLink) {
-                node = await link_node_1.LinkNode.makeForExisting(this.storage, this.objId, name, childInfo.objId, childInfo.key);
+            if (info.isFile) {
+                node = await file_node_1.FileNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
+            }
+            else if (info.isFolder) {
+                const src = await this.storage.getObjSrc(info.objId);
+                node = await FolderNode.readNodeFromObjBytes(this.storage, info.name, info.objId, src, info.key);
+            }
+            else if (info.isLink) {
+                node = await link_node_1.LinkNode.makeForExisting(this.storage, this.objId, info.name, info.objId, info.key);
             }
             else {
                 throw new Error(`Unknown type of fs node`);
@@ -245,9 +309,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         catch (exc) {
             deferred.reject(exc);
             if (exc.objNotFound) {
-                await this.fixMissingChildAndThrow(exc, childInfo);
+                await this.fixMissingChildAndThrow(exc, info);
             }
-            throw error_1.errWithCause(exc, `Cannot instantiate ${type} node '${this.name}/${childInfo.name}' from obj ${childInfo.objId}`);
+            throw (0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`);
         }
     }
     getFolder(name, undefOnMissing = false) {
@@ -261,16 +325,21 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     async fixMissingChildAndThrow(exc, childInfo) {
         await this.doTransition(async (state, version) => {
+            const presentChild = state.nodes[childInfo.name];
+            if (!presentChild || (presentChild.objId !== childInfo.objId)) {
+                return [];
+            }
             delete state.nodes[childInfo.name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
+                src: 'local',
                 name: childInfo.name,
                 newVersion: version
             };
-            return event;
+            return { event, childObjId: childInfo.objId };
         }).catch(noop);
-        const fileExc = file_1.makeFileException(file_1.Code.notFound, childInfo.name, exc);
+        const fileExc = (0, file_1.makeFileException)('notFound', childInfo.name, exc);
         fileExc.inconsistentStateOfFS = true;
         throw fileExc;
     }
@@ -289,11 +358,11 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     async performTransition(change) {
         // start transition and prepare transition state
         // Note on copy: byte arrays are not cloned
-        const state = json_utils_1.copy(this.currentState);
+        const state = (0, json_utils_1.copy)(this.currentState);
         const version = this.version + 1;
         const attrs = this.attrs.copy();
         // do action within transition state
-        const event = await change(state, version);
+        const changeEvents = await change(state, version);
         // save transition state
         const encSub = await this.crypto.write(state, version, attrs, this.xattrs);
         await this.storage.saveObj(this.objId, version, encSub);
@@ -301,7 +370,15 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         this.currentState = state;
         this.setCurrentVersion(version);
         this.attrs = attrs;
-        this.broadcastEvent(event);
+        if (Array.isArray(changeEvents)) {
+            for (const { event, childObjId } of changeEvents) {
+                this.broadcastEvent(event, false, childObjId);
+            }
+        }
+        else {
+            const { event, childObjId } = changeEvents;
+            this.broadcastEvent(event, false, childObjId);
+        }
     }
     /**
      * This function only creates folder node, but it doesn't insert it anywhere.
@@ -310,7 +387,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     async makeAndSaveNewChildFolderNode(name, changes) {
         const key = await random.bytes(xsp_files_1.KEY_LENGTH);
         const childObjId = await this.storage.generateNewObjId();
-        const node = new FolderNode(this.storage, name, childObjId, undefined, 0, this.objId, key, true);
+        const node = new FolderNode(this.storage, name, childObjId, (0, xsp_files_1.idToHeaderNonce)(childObjId), 0, this.objId, key, true);
         await node.saveFirstVersion(changes).catch((exc) => {
             if (!exc.objExists) {
                 throw exc;
@@ -369,7 +446,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             // do check for concurrent creation of a node
             if (this.getNodeInfo(name, true)) {
                 if (exclusive) {
-                    throw file_1.makeFileException(file_1.Code.alreadyExists, name);
+                    throw (0, file_1.makeFileException)('alreadyExists', name);
                 }
                 else if (type === 'folder') {
                     return (await this.getNode('folder', name));
@@ -405,15 +482,11 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 const event = {
                     type: 'entry-addition',
                     path: this.name,
+                    src: 'local',
                     newVersion: version,
-                    entry: {
-                        name: node.name,
-                        isFile: (node.type === 'file'),
-                        isFolder: (node.type === 'folder'),
-                        isLink: (node.type === 'link')
-                    }
+                    entry: nodeToListingEntry(node)
                 };
-                return event;
+                return { event, childObjId: node.objId };
             });
             return node;
         });
@@ -437,15 +510,16 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const event = {
                 type: 'entry-removal',
                 path: this.name,
+                src: 'local',
                 name: f.name,
                 newVersion: version
             };
-            return event;
+            return { event, childObjId: f.objId };
         });
         // explicitly do not wait on a result of child's delete, cause if it fails
         // we just get traceable garbage, yet, the rest of a live/non-deleted tree
         // stays consistent
-        f.localDelete();
+        this.callRemoveObjOn('local', f);
     }
     changeChildName(initName, newName) {
         return this.doTransition(async (state, version) => {
@@ -460,16 +534,17 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const event = {
                 type: 'entry-renaming',
                 path: this.name,
+                src: 'local',
                 newName,
                 oldName: initName,
                 newVersion: version
             };
-            return event;
+            return { event, childObjId: child.objId };
         });
     }
     async moveChildTo(childName, dst, nameInDst) {
         if (dst.hasChild(nameInDst)) {
-            throw file_1.makeFileException(file_1.Code.alreadyExists, nameInDst);
+            throw (0, file_1.makeFileException)('alreadyExists', nameInDst);
         }
         if (dst === this) {
             // In this case we only need to change child's name
@@ -480,40 +555,38 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             // we have two transitions here, in this and in dst.
             const moveLabel = getMoveLabel();
             await dst.moveChildIn(nameInDst, childJSON, moveLabel);
-            await this.moveChildOut(childName, moveLabel);
+            await this.moveChildOut(childName, childJSON.objId, moveLabel);
         }
     }
-    async moveChildOut(name, moveLabel) {
+    async moveChildOut(name, childObjId, moveLabel) {
         await this.doTransition(async (state, version) => {
+            const child = state.nodes[name];
             delete state.nodes[name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
+                src: 'local',
                 name,
                 newVersion: version,
                 moveLabel
             };
-            return event;
+            return { event, childObjId };
         });
     }
     async moveChildIn(newName, child, moveLabel) {
-        child = json_utils_1.copy(child);
+        child = (0, json_utils_1.copy)(child);
         await this.doTransition(async (state, version) => {
             child.name = newName;
             state.nodes[child.name] = child;
             const event = {
                 type: 'entry-addition',
                 path: this.name,
-                entry: {
-                    name: child.name,
-                    isFile: child.isFile,
-                    isFolder: child.isFolder,
-                    isLink: child.isLink
-                },
+                src: 'local',
+                entry: nodeInfoToListingEntry(child),
                 newVersion: version,
                 moveLabel
             };
-            return event;
+            return { event, childObjId: child.objId };
         });
     }
     async getFolderInThisSubTree(path, createIfMissing = false, exclusiveCreate = false) {
@@ -526,7 +599,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             // existing folder at this point
             if (path.length === 1) {
                 if (exclusiveCreate) {
-                    throw file_1.makeFileException(file_1.Code.alreadyExists, path[0]);
+                    throw (0, file_1.makeFileException)('alreadyExists', path[0]);
                 }
                 else {
                     return f;
@@ -583,28 +656,91 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         return content;
     }
-    async delete(remoteEvent) {
-        if (remoteEvent) {
-            return super.delete(true);
+    async removeFolderObj(src, passIdsForRmUpload = false) {
+        const childrenNodes = await this.doChange(true, async () => {
+            const childrenNodes = await this.getAllNodes();
+            await this.removeThisNodeAsLeaf(src);
+            return childrenNodes;
+        });
+        if (childrenNodes.length === 0) {
+            return;
         }
-        const childrenNodes = await this.getAllNodes();
-        await this.storage.removeObj(this.objId);
-        this.storage.nodes.delete(this);
-        this.setCurrentVersion(-1);
-        this.currentState = { nodes: {} };
-        const event = {
-            type: 'removed',
-            path: this.name,
-            isRemote: remoteEvent
-        };
-        this.broadcastEvent(event, true);
-        // explicitly do not wait on a result of child's delete, cause if it fails
-        // we just get traceable garbage, yet, the rest of a live/non-deleted tree
-        // stays consistent
-        for (const node of childrenNodes) {
-            node.localDelete();
+        if (this.isInSyncedStorage) {
+            if (passIdsForRmUpload) {
+                return this.removeChildrenObjsInSyncedStorage(childrenNodes, src, true);
+            }
+            else {
+                this.removeChildrenObjsInSyncedStorage(childrenNodes, src, false);
+            }
+        }
+        else {
+            this.callRemoveObjOnAll(src, childrenNodes);
         }
     }
+    callRemoveObjOnAll(src, nodes) {
+        for (const f of nodes) {
+            this.callRemoveObjOn(src, f);
+        }
+    }
+    async removeChildrenObjsInSyncedStorage(childrenNodes, src, passIdsForRmUpload) {
+        let uploadRmsHere;
+        let collectedIds;
+        if (passIdsForRmUpload) {
+            collectedIds = [];
+            uploadRmsHere = false;
+        }
+        else {
+            try {
+                const status = await this.syncedStorage().status(this.objId);
+                if (status.neverUploaded()) {
+                    collectedIds = [];
+                    uploadRmsHere = true;
+                }
+                else {
+                    collectedIds = undefined;
+                    uploadRmsHere = false;
+                }
+            }
+            catch (exc) {
+                if (exc.objNotFound) {
+                    collectedIds = [];
+                    uploadRmsHere = true;
+                }
+                else {
+                    throw exc;
+                }
+            }
+        }
+        if (!collectedIds) {
+            this.callRemoveObjOnAll(src, childrenNodes);
+            return;
+        }
+        await Promise.allSettled(childrenNodes.map(async (child) => {
+            const status = await this.syncedStorage().status(child.objId);
+            if (!status.neverUploaded()) {
+                collectedIds.push(child.objId);
+            }
+            if (child.type === 'folder') {
+                const ids = await child.removeFolderObj(src, passIdsForRmUpload);
+                if (ids) {
+                    collectedIds.push(...ids);
+                }
+            }
+            else {
+                await child.removeNonFolderObj(src);
+            }
+        }));
+        if (uploadRmsHere) {
+            await this.uploadRemovalOfObjs(collectedIds);
+        }
+        else {
+            return collectedIds;
+        }
+    }
+    async uploadRemovalOfObjs(objsToRm) {
+        objsToRm.sort(); // shuffle order
+        await Promise.allSettled(objsToRm.map(objToRm => this.syncedStorage().uploadObjRemoval(objToRm)));
+    }
     getParamsForLink() {
         if ((this.storage.type !== 'synced') && (this.storage.type !== 'local')) {
             throw new Error(`Creating link parameters to object in ${this.storage.type} file system, is not implemented.`);
@@ -621,77 +757,270 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         };
         return linkParams;
     }
-    // XXX make default conflict resolution for folder
-    // async resolveConflict(remoteVersion: number): Promise<void> {
-    // 	// XXX we need to read remote version outside of doChange
-    // 	const src = await (this.storage as SyncedStorage).getSyncedObjVersion(
-    // 		this.objId, remoteVersion);
-    // 	const remInfo = await this.crypto.open(src);
-    // 	await this.doChange(true, async () => {
-    // 		// XXX this is a default conflict resolution
-    // 		// XXX drop all previous local versions(!)
-    // 	});
-    // }
-    async doOnExternalChange(expectedVersion) {
-        if (expectedVersion <= this.version) {
-            return;
+    async upload(opts) {
+        try {
+            const toUpload = await this.needUpload(opts === null || opts === void 0 ? void 0 : opts.localVersion);
+            if (!toUpload) {
+                return;
+            }
+            if (toUpload.createOnRemote) {
+                await super.upload(opts);
+                return;
+            }
+            const storage = this.syncedStorage();
+            const { localVersion, uploadVersion } = toUpload;
+            const removedNodes = await this.getNodesRemovedBetweenVersions(localVersion, uploadVersion - 1);
+            const uploadHeader = await this.uploadHeaderChange(localVersion, uploadVersion);
+            await storage.upload(this.objId, localVersion, uploadVersion, uploadHeader, false);
+            if (removedNodes.length > 0) {
+                // start upload of children's removal after folder's upload;
+                // we also don't await for chidren removal
+                this.uploadRemovalOf(removedNodes);
+            }
         }
-        const src = await this.storage.getObj(this.objId);
-        const newVersion = src.version;
-        if (newVersion <= this.version) {
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, this.name);
+        }
+    }
+    async uploadRemovalOf(removedNodes) {
+        const storage = this.syncedStorage();
+        const rmObjs = [];
+        for (const node of removedNodes) {
+            (0, for_arrays_1.appendArray)(rmObjs, await this.listRemovedInTreeToUploadRm(node));
+        }
+        await this.uploadRemovalOfObjs(rmObjs);
+    }
+    async listRemovedInTreeToUploadRm(node) {
+        const storage = this.syncedStorage();
+        let versionBeforeRm;
+        try {
+            const status = await storage.status(node.objId);
+            versionBeforeRm = status.versionBeforeUnsyncedRemoval();
+            if (!versionBeforeRm) {
+                return;
+            }
+        }
+        catch (exc) {
+            if (exc.objNotFound
+                || exc.notFound) {
+                return;
+            }
+            throw exc;
+        }
+        if (node.isFolder) {
+            const objs = [node.objId];
+            const src = await storage.getObjSrc(node.objId, versionBeforeRm, true);
+            const folderContent = await FolderPersistance.readFolderContent(node.objId, node.key, src, storage.cryptor);
+            for (const child of Object.values(folderContent.nodes)) {
+                (0, for_arrays_1.appendArray)(objs, await this.listRemovedInTreeToUploadRm(child));
+            }
+            return objs;
+        }
+        else {
+            return node.objId;
+        }
+    }
+    async needUpload(localVersion) {
+        const toUpload = await super.needUpload(localVersion);
+        if (!toUpload) {
             return;
         }
-        const { folderInfo, attrs } = await this.crypto.read(src);
-        const initState = this.currentState;
-        this.currentState = checkFolderInfo(folderInfo);
-        this.setCurrentVersion(newVersion);
-        if (attrs) {
-            this.attrs = attrs;
-        }
-        const addedEntries = Object.keys(this.currentState.nodes)
-            .filter(name => !initState.nodes[name]);
-        const removedEntries = Object.keys(initState.nodes)
-            .filter(name => !this.currentState.nodes[name]);
-        if ((addedEntries.length === 1) && (removedEntries.length === 1)) {
+        const storage = this.syncedStorage();
+        if (toUpload.localVersion === this.version) {
+            for (const { objId, name } of Object.values(this.currentState.nodes)) {
+                if ((await storage.status(objId)).neverUploaded()) {
+                    throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                        childNeverUploaded: true, childName: name
+                    });
+                }
+            }
+        }
+        else {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                versionMismatch: true,
+                localVersion: toUpload.localVersion,
+                message: `Local version has concurrently changed from ${toUpload.localVersion} to current ${this.version}`
+            });
+        }
+        return toUpload;
+    }
+    async getNodesRemovedBetweenVersions(newVer, syncedVer) {
+        const storage = this.syncedStorage();
+        let stateToUpload;
+        if (this.version === newVer) {
+            stateToUpload = this.currentState;
+        }
+        else {
+            const localVerSrc = await storage.getObjSrcOfRemoteVersion(this.objId, newVer);
+            ({ folderInfo: stateToUpload } = await this.crypto.read(localVerSrc));
+        }
+        const syncedVerSrc = await storage.getObjSrcOfRemoteVersion(this.objId, syncedVer);
+        const { folderInfo: syncedState } = await this.crypto.read(syncedVerSrc);
+        const { removedNodes } = identifyChanges(syncedState.nodes, stateToUpload.nodes);
+        return removedNodes;
+    }
+    async adoptRemoteFolderItem(itemName, opts) {
+        if (opts === null || opts === void 0 ? void 0 : opts.localVersion) {
+            if (this.version !== opts.localVersion) {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    message: `Given local version ${opts.localVersion} is not equal to current ${this.version}`
+                });
+            }
+        }
+        const { remote } = await this.syncStatus();
+        if (!remote) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                versionMismatch: true,
+                message: `No remote versions`
+            });
+        }
+        if (opts === null || opts === void 0 ? void 0 : opts.remoteVersion) {
+            if (opts.remoteVersion !== remote.latest) {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    message: `Unknown remote version ${opts.remoteVersion}`
+                });
+            }
+        }
+        else if (!remote.latest) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                remoteIsArchived: true
+            });
+        }
+        const storage = this.syncedStorage();
+        const srcOfRemote = await storage.getObjSrcOfRemoteVersion(this.objId, remote.latest);
+        const { folderInfo: { nodes: remoteNodes } } = await this.crypto.read(srcOfRemote);
+        const remoteChildNode = remoteNodes[itemName];
+        if (!remoteChildNode) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                remoteFolderItemNotFound: true,
+                message: `Item '${itemName}' is not found in remote version`
+            });
+        }
+        const localNodeToRm = this.getNodeInfo(itemName, true);
+        if (!localNodeToRm) {
+            return await this.addRemoteChild(remoteChildNode);
+        }
+        else if (localNodeToRm.objId === remoteChildNode.objId) {
+            (0, assert_1.assert)(typeOfNode(localNodeToRm) === typeOfNode(remoteChildNode));
+            // XXX
+            throw new Error(`Adaptation of changing keys needs implementation`);
+        }
+        else {
+            return await this.replaceLocalChildWithRemote(remoteChildNode);
+        }
+    }
+    async addRemoteChild(remoteChildNode) {
+        let newVersion;
+        await this.doTransition(async (state, version) => {
+            newVersion = version;
+            state.nodes[remoteChildNode.name] = remoteChildNode;
             const event = {
-                type: 'entry-renaming',
+                type: 'entry-addition',
                 path: this.name,
-                isRemote: true,
-                oldName: removedEntries[0],
-                newName: addedEntries[0],
+                src: 'sync',
+                entry: nodeInfoToListingEntry(remoteChildNode),
                 newVersion
             };
-            this.broadcastEvent(event);
+            return { event, childObjId: remoteChildNode.objId };
+        });
+        return newVersion;
+    }
+    async replaceLocalChildWithRemote(remoteChildNode) {
+        let origChildNode;
+        let newVersion;
+        await this.doTransition(async (state, version) => {
+            newVersion = version;
+            origChildNode = state.nodes[remoteChildNode.name];
+            state.nodes[remoteChildNode.name] = remoteChildNode;
+            const additionEvent = {
+                type: 'entry-addition',
+                path: this.name,
+                src: 'sync',
+                entry: nodeInfoToListingEntry(remoteChildNode),
+                newVersion
+            };
+            const rmEvent = {
+                type: 'entry-removal',
+                path: this.name,
+                src: 'sync',
+                name: origChildNode.name
+            };
+            return [
+                { event: rmEvent, childObjId: origChildNode.objId },
+                { event: additionEvent, childObjId: remoteChildNode.objId }
+            ];
+        });
+        const origChild = await this.getOrMakeChildNodeForInfo(origChildNode);
+        const removalsToUpload = (await this.removeChildrenObjsInSyncedStorage([origChild], 'sync', true));
+        this.uploadRemovalOfObjs(removalsToUpload);
+        return newVersion;
+    }
+    async diffCurrentAndRemote(remoteVersion) {
+        var _a;
+        const { state, remote } = await this.syncStatus();
+        let isCurrentLocal;
+        if (state === 'behind') {
+            isCurrentLocal = false;
+        }
+        else if (state === 'conflicting') {
+            isCurrentLocal = true;
         }
         else {
-            addedEntries.forEach(name => {
-                const addedNode = this.currentState.nodes[name];
-                const event = {
-                    type: 'entry-addition',
-                    path: this.name,
-                    isRemote: true,
-                    entry: {
-                        name: addedNode.name,
-                        isFile: addedNode.isFile,
-                        isFolder: addedNode.isFolder,
-                        isLink: addedNode.isLink
-                    },
-                    newVersion
-                };
-                this.broadcastEvent(event);
-            });
-            removedEntries.forEach(name => {
-                const event = {
-                    type: 'entry-removal',
-                    path: this.name,
-                    isRemote: true,
-                    name,
-                    newVersion
-                };
-                this.broadcastEvent(event);
-            });
+            return;
+        }
+        if (remote.isArchived) {
+            return this.diffWithArchivedRemote(isCurrentLocal);
+        }
+        else {
+            if (remoteVersion) {
+                if ((remoteVersion !== remote.latest)
+                    && !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(remoteVersion))) {
+                    throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                        versionMismatch: true,
+                        message: `Unknown remote version ${remoteVersion}`
+                    });
+                }
+            }
+            else {
+                remoteVersion = remote.latest;
+            }
+            const storage = this.syncedStorage();
+            const srcOfRemote = await storage.getObjSrcOfRemoteVersion(this.objId, remote.latest);
+            const { folderInfo, attrs, xattrs } = await this.crypto.read(srcOfRemote);
+            return this.diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs);
         }
     }
+    diffWithArchivedRemote(isCurrentLocal) {
+        return {
+            currentVersion: this.version,
+            isCurrentLocal,
+            isRemoteArchived: true,
+            ctime: {
+                current: new Date(this.attrs.ctime)
+            },
+            mtime: {
+                current: new Date(this.attrs.ctime)
+            }
+        };
+    }
+    diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs) {
+        const { ctime, mtime } = diffAttrs(this.attrs, attrs);
+        const { inCurrent, inRemote, nameOverlaps } = diffNodes(this.currentState, folderInfo);
+        return {
+            currentVersion: this.version,
+            isCurrentLocal,
+            isRemoteArchived: false,
+            remoteVersion,
+            inCurrent,
+            inRemote,
+            nameOverlaps,
+            ctime,
+            mtime,
+            xattrs: diffXAttrs(this.xattrs, xattrs)
+        };
+    }
 }
 exports.FolderNode = FolderNode;
 Object.freeze(FolderNode.prototype);
@@ -702,6 +1031,46 @@ function checkFolderInfo(folderJson) {
     // TODO throw if folderJson is not ok
     return folderJson;
 }
+function nodeInfoToListingEntry({ name, isFile, isFolder, isLink }) {
+    if (isFolder) {
+        return { name, isFolder };
+    }
+    else if (isFile) {
+        return { name, isFile };
+    }
+    else if (isLink) {
+        return { name, isLink };
+    }
+    else {
+        return { name };
+    }
+}
+function nodeToListingEntry({ name, type }) {
+    switch (type) {
+        case 'file':
+            return { name, isFolder: true };
+        case 'folder':
+            return { name, isFolder: true };
+        case 'link':
+            return { name, isLink: true };
+        default:
+            return { name };
+    }
+}
+function typeOfNode(nodeInfo) {
+    if (nodeInfo.isFolder) {
+        return 'folder';
+    }
+    else if (nodeInfo.isFile) {
+        return 'file';
+    }
+    else if (nodeInfo.isLink) {
+        return 'link';
+    }
+    else {
+        throw new Error(`Unknown type of node info`);
+    }
+}
 function addToTransitionState(state, f, key) {
     const nodeInfo = {
         name: f.name,
@@ -722,4 +1091,195 @@ function addToTransitionState(state, f, key) {
     }
     state.nodes[nodeInfo.name] = nodeInfo;
 }
+function diffAttrs(current, remote) {
+    return {
+        ctime: {
+            current: new Date(current.ctime),
+            remote: new Date(remote.ctime)
+        },
+        mtime: {
+            current: new Date(current.mtime),
+            remote: new Date(remote.mtime)
+        }
+    };
+}
+function diffNodes(current, remote) {
+    const inCurrent = getOnlyNotEqualNodes(current.nodes, remote.nodes);
+    const inRemote = getOnlyNotEqualNodes(remote.nodes, current.nodes);
+    const combined = combineCheckingNameOverlaps(inCurrent, inRemote);
+    return (combined ? combined : {});
+}
+function getOnlyNotEqualNodes(src, exclude) {
+    const collected = [];
+    for (const [name, nodeInSrc] of Object.entries(src)) {
+        const nodeInExclude = exclude[name];
+        if (!nodeInExclude
+            || !areNodesEqual(nodeInSrc, nodeInExclude)) {
+            collected.push(nodeInfoToListingEntry(nodeInSrc));
+        }
+    }
+    return ((collected.length > 0) ? collected : undefined);
+}
+function areNodesEqual(n1, n2) {
+    if (n1.name !== n2.name) {
+        return false;
+    }
+    if (n1.isFile && !n2.isFile) {
+        return false;
+    }
+    if (n1.isFolder && !n2.isFolder) {
+        return false;
+    }
+    if (n1.isLink && !n2.isLink) {
+        return false;
+    }
+    if (n1.objId !== n2.objId) {
+        return false;
+    }
+    if (!areBytesEqual(n1.key, n2.key)) {
+        return false;
+    }
+    return true;
+}
+function combineCheckingNameOverlaps(inCurrent, inRemote) {
+    if (inCurrent) {
+        if (inRemote) {
+            const nameOverlaps = [];
+            for (const { name: nameInCurrent } of inCurrent) {
+                if (inRemote.find(({ name }) => (name === nameInCurrent))) {
+                    nameOverlaps.push(nameInCurrent);
+                }
+            }
+            if (nameOverlaps.length > 0) {
+                return { inCurrent, inRemote, nameOverlaps };
+            }
+            else {
+                return { inCurrent, inRemote };
+            }
+        }
+        else {
+            return { inCurrent };
+        }
+    }
+    else {
+        if (inRemote) {
+            return { inRemote };
+        }
+        else {
+            return;
+        }
+    }
+}
+function diffXAttrs(current, remote) {
+    const haveCurrentXAttrs = (current && (current.list().length > 0));
+    const haveRemoteXAttrs = (remote && (remote.list().length > 0));
+    if (haveCurrentXAttrs && haveRemoteXAttrs) {
+        const inCurrent = getOnlyNotEqualXAttrs(current, remote);
+        const inRemote = getOnlyNotEqualXAttrs(remote, current);
+        return combineCheckingNameOverlaps(inCurrent, inRemote);
+    }
+    else if (haveCurrentXAttrs && !haveRemoteXAttrs) {
+        return { inCurrent: allXAttrsToDiff(current) };
+    }
+    else if (!haveCurrentXAttrs && haveRemoteXAttrs) {
+        return { inRemote: allXAttrsToDiff(remote) };
+    }
+    else {
+        return;
+    }
+}
+function allXAttrsToDiff(src) {
+    const collected = [];
+    for (const name of src.list()) {
+        const value = src.get(name);
+        if (value !== undefined) {
+            collected.push({ name, value });
+        }
+    }
+    return collected;
+}
+function getOnlyNotEqualXAttrs(src, exclude) {
+    const collected = [];
+    for (const name of src.list()) {
+        const valueInSrc = src.get(name);
+        if (valueInSrc === undefined) {
+            continue;
+        }
+        const valueInExclude = exclude.get(name);
+        if ((valueInExclude === undefined)
+            || !areXAttrValuesEqual(valueInSrc, valueInExclude)) {
+            collected.push({ name, value: valueInSrc });
+        }
+    }
+    return ((collected.length > 0) ? collected : undefined);
+}
+function areXAttrValuesEqual(v1, v2) {
+    if (Buffer.isBuffer(v1) || ArrayBuffer.isView(v1)) {
+        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)) {
+            return areBytesEqual(v1, v2);
+        }
+        {
+            return false;
+        }
+    }
+    else if (typeof v1 === 'string') {
+        if (typeof v2 === 'string') {
+            return (v1 === v2);
+        }
+        else {
+            return false;
+        }
+    }
+    else {
+        if (Buffer.isBuffer(v2) || ArrayBuffer.isView(v2)
+            || (typeof v2 === 'string')) {
+            return false;
+        }
+        else {
+            return (0, json_utils_1.deepEqual)(v1, v2);
+        }
+    }
+}
+function areBytesEqual(b1, b2) {
+    if (b1.length !== b2.length) {
+        return false;
+    }
+    for (let i = 0; i < b1.length; i += 1) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function identifyChanges(originalNodes, newNodes) {
+    const removedNodes = [];
+    const addedNodes = [];
+    const renamedNodes = [];
+    for (const [name, node] of Object.entries(originalNodes)) {
+        const newNode = newNodes[name];
+        if (newNode && (newNode.objId === node.objId)) {
+            continue;
+        }
+        removedNodes.push(node);
+    }
+    for (const [name, newNode] of Object.entries(newNodes)) {
+        const node = originalNodes[name];
+        if (node && (newNode.objId === node.objId)) {
+            continue;
+        }
+        const indInRm = removedNodes.findIndex(n => (n.objId === newNode.objId));
+        if (indInRm < 0) {
+            addedNodes.push(newNode);
+        }
+        else {
+            const oldNode = removedNodes.splice(indInRm, 1)[0];
+            renamedNodes.push({
+                oldName: oldNode.name,
+                newName: newNode.name,
+                objId: newNode.objId
+            });
+        }
+    }
+    return { addedNodes, removedNodes, renamedNodes };
+}
 Object.freeze(exports);