core-3nweb-client-lib 0.27.1 → 0.27.3

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

@@ -37,6 +37,7 @@ 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: (0, json_utils_1.copy)(json.nodes)
@@ -62,6 +63,14 @@ class FolderPersistance extends node_persistence_1.NodePersistance {
         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);
@@ -84,7 +93,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             (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");
+            throw new Error("Missing objId for non-root folder");
         }
         this.crypto = new FolderPersistance(zNonce, key, storage.cryptor);
         if (setNewAttrs) {
@@ -198,7 +207,16 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             return;
         }
         for (const objToRm of objsToRm) {
-            (await this.getOrMakeChildNodeForInfo(objToRm)).removeObj('sync');
+            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() {
@@ -207,18 +225,25 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return { lst, version: this.version };
     }
     async childExistsInSyncedVersion(childObjId) {
-        const status = await this.syncStatus();
-        if (status.state === 'synced') {
+        const { state, synced } = await this.syncStatus();
+        if (state === 'synced') {
             return true;
         }
-        if (!status.synced) {
+        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;
         }
-        // XXX FolderNode.childExistsInSyncedVersion() should implement check in synced version
-        return false;
-    }
-    listFolders() {
-        return Object.keys(this.currentState.nodes).filter(name => !!this.currentState.nodes[name].isFolder);
     }
     getNodeInfo(name, undefOnMissing = false) {
         const fj = this.currentState.nodes[name];
@@ -229,7 +254,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             return;
         }
         else {
-            throw (0, file_1.makeFileException)(file_1.Code.notFound, name);
+            throw (0, file_1.makeFileException)('notFound', name);
         }
     }
     hasChild(childName, throwIfMissing = false) {
@@ -242,13 +267,13 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         if (type) {
             if ((type === 'file') && !childInfo.isFile) {
-                throw (0, file_1.makeFileException)(file_1.Code.notFile, childInfo.name);
+                throw (0, file_1.makeFileException)('notFile', childInfo.name);
             }
             else if ((type === 'folder') && !childInfo.isFolder) {
-                throw (0, file_1.makeFileException)(file_1.Code.notDirectory, childInfo.name);
+                throw (0, file_1.makeFileException)('notDirectory', childInfo.name);
             }
             else if ((type === 'link') && !childInfo.isLink) {
-                throw (0, file_1.makeFileException)(file_1.Code.notLink, childInfo.name);
+                throw (0, file_1.makeFileException)('notLink', childInfo.name);
             }
         }
         return this.getOrMakeChildNodeForInfo(childInfo);
@@ -314,7 +339,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             };
             return { event, childObjId: childInfo.objId };
         }).catch(noop);
-        const fileExc = (0, 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;
     }
@@ -421,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 (0, 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));
@@ -494,7 +519,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         // 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.removeObj();
+        this.callRemoveObjOn('local', f);
     }
     changeChildName(initName, newName) {
         return this.doTransition(async (state, version) => {
@@ -519,7 +544,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     async moveChildTo(childName, dst, nameInDst) {
         if (dst.hasChild(nameInDst)) {
-            throw (0, 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
@@ -574,7 +599,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             // existing folder at this point
             if (path.length === 1) {
                 if (exclusiveCreate) {
-                    throw (0, file_1.makeFileException)(file_1.Code.alreadyExists, path[0]);
+                    throw (0, file_1.makeFileException)('alreadyExists', path[0]);
                 }
                 else {
                     return f;
@@ -631,22 +656,91 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         return content;
     }
-    async delete(src) {
-        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,
-            src
-        };
-        this.broadcastEvent(event, true);
-        for (const node of childrenNodes) {
-            node.removeObj(src);
+    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;
+        }
+        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.`);
@@ -664,24 +758,73 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return linkParams;
     }
     async upload(opts) {
-        // XXX temporary use of super's method
-        return super.upload(opts);
-        // const storage = this.syncedStorage();
-        // XXX
-        //  - use identifyChanges() to find changes, minding particular version,
-        //    ensuring that concurrent change won't mess things up.
-        //  - items not present in uploaded version, relative to latest sync,
-        //    i.e. removed, removal should be uploaded with
-        //    storage.uploadObjRemoval(objId);
+        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);
+            }
+        }
+        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;
         }
-        // XXX can put the following into private ensureAllChildrenUploaded(),
-        //     but it also need to get a consistent state, while current one can
-        //     be broken by simultaneous change in folder.
         const storage = this.syncedStorage();
         if (toUpload.localVersion === this.version) {
             for (const { objId, name } of Object.values(this.currentState.nodes)) {
@@ -693,10 +836,29 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             }
         }
         else {
-            throw new Error(`Reading particular version is not implemented, yet`);
+            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) {
@@ -741,10 +903,12 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             return await this.addRemoteChild(remoteChildNode);
         }
         else if (localNodeToRm.objId === remoteChildNode.objId) {
-            return await this.setRemoteNodeInfo(remoteChildNode);
+            (0, assert_1.assert)(typeOfNode(localNodeToRm) === typeOfNode(remoteChildNode));
+            // XXX
+            throw new Error(`Adaptation of changing keys needs implementation`);
         }
         else {
-            return await this.replaceLocalChildWithRemote(localNodeToRm, remoteChildNode);
+            return await this.replaceLocalChildWithRemote(remoteChildNode);
         }
     }
     async addRemoteChild(remoteChildNode) {
@@ -761,25 +925,14 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             };
             return { event, childObjId: remoteChildNode.objId };
         });
-        // XXX child should update sync info, and adopt change.
         return newVersion;
     }
-    async setRemoteNodeInfo(remoteChildNode) {
+    async replaceLocalChildWithRemote(remoteChildNode) {
+        let origChildNode;
         let newVersion;
         await this.doTransition(async (state, version) => {
             newVersion = version;
-            state.nodes[remoteChildNode.name] = remoteChildNode;
-            return [];
-        });
-        // XXX child should update sync info, and adopt change, cause changed key
-        //     requires changed cypher.
-        return newVersion;
-    }
-    async replaceLocalChildWithRemote(origChildNode, remoteChildNode) {
-        let newVersion;
-        await this.doTransition(async (state, version) => {
-            newVersion = version;
-            const presentNode = state.nodes[remoteChildNode.name];
+            origChildNode = state.nodes[remoteChildNode.name];
             state.nodes[remoteChildNode.name] = remoteChildNode;
             const additionEvent = {
                 type: 'entry-addition',
@@ -799,12 +952,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 { event: additionEvent, childObjId: remoteChildNode.objId }
             ];
         });
-        // XXX
-        //  remote child should update sync info, and adopt change. 
-        //  original child:
-        //  - if only local, should be removed,
-        //  - else should update sync info, and adopt both removal and change.
-        (await this.getOrMakeChildNodeForInfo(origChildNode)).removeObj('sync');
+        const origChild = await this.getOrMakeChildNodeForInfo(origChildNode);
+        const removalsToUpload = (await this.removeChildrenObjsInSyncedStorage([origChild], 'sync', true));
+        this.uploadRemovalOfObjs(removalsToUpload);
         return newVersion;
     }
     async diffCurrentAndRemote(remoteVersion) {
@@ -907,6 +1057,20 @@ function nodeToListingEntry({ name, type }) {
             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,

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

@@ -68,7 +68,7 @@ class XspFS {
     }
     storage() {
         if (!this.store) {
-            throw (0, file_1.makeFileException)(file_1.Code.storageClosed, this.name);
+            throw (0, file_1.makeFileException)('storageClosed', this.name);
         }
         return this.store;
     }
@@ -146,8 +146,10 @@ class XspFS {
         const folder = (await parentFolder.getFolder(folderName)
             .catch(setExcPath(path)));
         if (!removeContent && !folder.isEmpty()) {
-            throw (0, file_1.makeFileException)(file_1.Code.notEmpty, path);
+            throw (0, file_1.makeFileException)('notEmpty', path);
         }
+        // note that internal folder.delete() removes all children as a matter
+        // of not leaving inaccessible nodes, i.e. content is removed implicitly
         await parentFolder.removeChild(folder);
     }
     async deleteFile(path) {
@@ -252,17 +254,11 @@ class XspFS {
             return true;
         }
         else if (throwIfMissing) {
-            let code = '';
-            if (type === 'file') {
-                code = file_1.Code.notFile;
+            switch (type) {
+                case 'file': throw (0, file_1.makeFileException)('notFile', path);
+                case 'folder': throw (0, file_1.makeFileException)('notDirectory', path);
+                case 'link': throw (0, file_1.makeFileException)('notLink', path);
             }
-            else if (type === 'folder') {
-                code = file_1.Code.notDirectory;
-            }
-            else if (type === 'link') {
-                code = file_1.Code.notLink;
-            }
-            throw (0, file_1.makeFileException)(code, path);
         }
         else {
             return false;
@@ -415,14 +411,14 @@ class XspFS {
         const exists = await this.checkFilePresence(path);
         if (exists) {
             if (flags.create && flags.exclusive) {
-                throw (0, file_1.makeFileException)(file_1.Code.alreadyExists, path);
+                throw (0, file_1.makeFileException)('alreadyExists', path);
             }
             const fNode = await this.v.getOrCreateFile(path, flags);
             return (0, files_1.wrapWritableFile)(file_2.FileObject.makeExisting(fNode, true));
         }
         else {
             if (!flags.create) {
-                throw (0, file_1.makeFileException)(file_1.Code.notFound, path);
+                throw (0, file_1.makeFileException)('notFound', path);
             }
             return (0, files_1.wrapWritableFile)(file_2.FileObject.makeForNotExisiting(path_1.posix.basename(path), () => this.v.getOrCreateFile(path, flags), !!this.v.sync));
         }
@@ -512,7 +508,7 @@ class V {
     }
     getRootIfNotClosed(excPath) {
         if (!this.rootNode) {
-            throw (0, file_1.makeFileException)(file_1.Code.storageClosed, excPath);
+            throw (0, file_1.makeFileException)('storageClosed', excPath);
         }
         return this.rootNode;
     }
@@ -525,7 +521,7 @@ class V {
             .catch(setExcPath(path));
         if (file) {
             if (exclusive) {
-                throw (0, file_1.makeFileException)(file_1.Code.alreadyExists, path);
+                throw (0, file_1.makeFileException)('alreadyExists', path);
             }
         }
         else {
@@ -591,7 +587,7 @@ class V {
             return { txt, version };
         }
         catch (err) {
-            throw (0, file_1.makeFileException)(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)('parsingError', path, err);
         }
     }
     writeJSONFile(path, json, flags = WRITE_NONEXCL_FLAGS) {
@@ -605,7 +601,7 @@ class V {
             return { json, version };
         }
         catch (err) {
-            throw (0, file_1.makeFileException)(file_1.Code.parsingError, path, err);
+            throw (0, file_1.makeFileException)('parsingError', path, err);
         }
     }
     async getByteSink(path, flags = WRITE_NONEXCL_FLAGS) {
@@ -780,7 +776,7 @@ class S {
     async getFolderNode(path) {
         const node = await this.n.get(path);
         if (node.type !== 'folder') {
-            throw (0, file_1.makeFileException)(file_1.Code.notDirectory, path);
+            throw (0, file_1.makeFileException)('notDirectory', path);
         }
         return node;
     }

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.d.ts

@@ -1,4 +1,4 @@
-import { FSChangeSrc, Node, NodeType, Storage, SyncedStorage } from './common';
+import { FSChangeSrc, Node, NodeType, Storage, SyncedStorage, UploadHeaderChange } from './common';
 import { Observable } from 'rxjs';
 import { CommonAttrs, XAttrs } from './attrs';
 import { NodePersistance } from './node-persistence';
@@ -40,13 +40,8 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         archived?: number[];
     }>;
     archiveCurrent(version?: number): Promise<number>;
-    removeObj(src?: FSChangeSrc): Promise<void>;
-    /**
-     * This non-synchronized method deletes object from storage, and detaches
-     * this node from storage. Make sure to call it inside access synchronization
-     * construct.
-     */
-    protected delete(src: FSChangeSrc): Promise<void>;
+    removeNonFolderObj(src: FSChangeSrc): Promise<void>;
+    protected removeThisNodeAsLeaf(src: FSChangeSrc): Promise<void>;
     /**
      * This method runs node changing function in an exclusive manner.
      * Returned promise resolves to whatever change function returns.
@@ -80,6 +75,6 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         createOnRemote: boolean;
     } | undefined>;
     upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
-    private uploadHeaderChange;
+    protected uploadHeaderChange(localVersion: number, uploadVersion: number): Promise<UploadHeaderChange | undefined>;
 }
 export {};