core-3nweb-client-lib 0.27.0 → 0.27.4

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() {
@@ -206,19 +224,33 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             .map(nodeInfoToListingEntry);
         return { lst, version: this.version };
     }
+    async listNonCurrent(flags) {
+        const src = await this.getObjSrcOfVersion(flags);
+        const { folderInfo } = await this.crypto.read(src);
+        const lst = Object.values(folderInfo)
+            .map(nodeInfoToListingEntry);
+        return { lst, version: src.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 +261,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 +274,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 +346,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 +453,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 +526,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 +551,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 +606,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 +663,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 +765,72 @@ 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 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 +842,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 +909,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 +931,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 +958,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 +1063,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.d.ts

@@ -21,6 +21,7 @@ declare type FSCollection = web3n.files.FSCollection;
 declare type FileFlags = web3n.files.FileFlags;
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
+declare type VersionedReadFlags = web3n.files.VersionedReadFlags;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
 declare type WritableFSSyncAPI = web3n.files.WritableFSSyncAPI;
 declare type SyncStatus = web3n.files.SyncStatus;
@@ -39,7 +40,7 @@ export declare class XspFS implements WritableFS {
     private constructor();
     private storage;
     readonlySubRoot(path: string): Promise<ReadonlyFS>;
-    writableSubRoot(path: string, flags?: web3n.files.VersionedFileFlags): Promise<WritableFS>;
+    writableSubRoot(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<WritableFS>;
     /**
      * This creates in a root object in a given storage, returning fs object
      * representing created root.
@@ -88,7 +89,7 @@ export declare class XspFS implements WritableFS {
     watchFile(path: string, observer: Observer<FileEvent>): () => void;
     watchTree(path: string, depth: number | undefined, observer: Observer<FolderEvent | FileEvent>): () => void;
     readonlyFile(path: string): Promise<ReadonlyFile>;
-    writableFile(path: string, flags?: web3n.files.VersionedFileFlags): Promise<WritableFile>;
+    writableFile(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<WritableFile>;
     copyFile(src: string, dst: string, overwrite?: boolean): Promise<void>;
     saveFile(file: File, dst: string, overwrite?: boolean): Promise<void>;
     listFolder(folder: string): Promise<ListingEntry[]>;
@@ -96,10 +97,10 @@ export declare class XspFS implements WritableFS {
     readTxtFile(path: string): Promise<string>;
     readBytes(path: string, start?: number, end?: number): Promise<Uint8Array | undefined>;
     getByteSource(path: string): Promise<FileByteSource>;
-    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileFlags): Promise<void>;
-    getByteSink(path: string, flags?: web3n.files.VersionedFileFlags): Promise<FileByteSink>;
+    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileWriteFlags): Promise<void>;
+    getByteSink(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<FileByteSink>;
 }
 interface N {
     get(path: string): Promise<NodeInFS<any>>;
@@ -121,38 +122,38 @@ declare class V implements WritableFSVersionedAPI, N {
     get(path: string): Promise<NodeInFS<any>>;
     ensureIsWritable(): void;
     updateXAttrs(path: string, changes: XAttrsChanges): Promise<number>;
-    getXAttr(path: string, xaName: string): Promise<{
+    getXAttr(path: string, xaName: string, flags?: VersionedReadFlags): Promise<{
         attr: any;
         version: number;
     }>;
-    listXAttrs(path: string): Promise<{
+    listXAttrs(path: string, flags?: VersionedReadFlags): Promise<{
         lst: string[];
         version: number;
     }>;
-    listFolder(path: string): Promise<{
+    listFolder(path: string, flags?: VersionedReadFlags): Promise<{
         lst: ListingEntry[];
         version: number;
     }>;
-    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readBytes(path: string, start?: number, end?: number): Promise<{
+    writeBytes(path: string, bytes: Uint8Array, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readBytes(path: string, start?: number, end?: number, flags?: VersionedReadFlags): Promise<{
         bytes: Uint8Array | undefined;
         version: number;
     }>;
-    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readTxtFile(path: string): Promise<{
+    writeTxtFile(path: string, txt: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readTxtFile(path: string, flags?: VersionedReadFlags): Promise<{
         txt: string;
         version: number;
     }>;
-    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileFlags): Promise<number>;
-    readJSONFile<T>(path: string): Promise<{
+    writeJSONFile(path: string, json: any, flags?: web3n.files.VersionedFileWriteFlags): Promise<number>;
+    readJSONFile<T>(path: string, flags?: VersionedReadFlags): Promise<{
         json: T;
         version: number;
     }>;
-    getByteSink(path: string, flags?: web3n.files.VersionedFileFlags): Promise<{
+    getByteSink(path: string, flags?: web3n.files.VersionedFileWriteFlags): Promise<{
         sink: FileByteSink;
         version: number;
     }>;
-    getByteSource(path: string): Promise<{
+    getByteSource(path: string, flags?: VersionedReadFlags): Promise<{
         src: FileByteSource;
         version: number;
     }>;