core-3nweb-client-lib 0.43.17 → 0.43.19

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -337,6 +337,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             else if (exc.failedCipherVerification) {
                 exc = (0, file_1.makeFileException)('ioError', `${this.name}/${info.name}`, exc);
             }
+            // XXX why and what ?
             deferred.reject((0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`));
             return nodeSet;
         }
@@ -370,6 +371,75 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         fileExc.inconsistentStateOfFS = true;
         throw fileExc;
     }
+    async adoptItemsFromRemoteVersion(opts) {
+        const { state, remote } = await this.syncStatus();
+        if ((state !== 'conflicting') && (state !== 'behind')) {
+            return;
+        }
+        const remoteVersion = versionFromRemoteBranch(remote, opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
+        if (!remoteVersion) {
+            throw 'something';
+        }
+        const { folderInfo: remoteState } = await this.readRemoteVersion(remoteVersion);
+        return await this.doChangeWhileTrackingVersion(opts === null || opts === void 0 ? void 0 : opts.localVersion, async (state) => {
+            const { inRemote, nameOverlaps, differentKeys } = diffNodes(state, remoteState);
+            if (differentKeys) {
+                throw 'something';
+            }
+            if (!inRemote) {
+                return [];
+            }
+            const addedNodes = new Set();
+            if (nameOverlaps) {
+                const postfix = opts === null || opts === void 0 ? void 0 : opts.postfixForNameOverlaps;
+                if ((postfix === undefined) || (postfix.length < 0)) {
+                    throw 'something';
+                }
+                for (const itemName of nameOverlaps) {
+                    const node = remoteState.nodes[itemName];
+                    let newName = `${itemName}${postfix}`;
+                    while (state.nodes[newName]) {
+                        newName = `${newName}${postfix}`;
+                    }
+                    node.name = newName;
+                    state.nodes[newName] = node;
+                    addedNodes.add(itemName);
+                }
+            }
+            for (const { name: itemName } of inRemote) {
+                if (addedNodes.has(itemName)) {
+                    continue;
+                }
+                const node = remoteState.nodes[itemName];
+                state.nodes[itemName] = node;
+            }
+            return [];
+        });
+    }
+    /**
+     * If no initial local version given, then this performs like doTransition(change) method.
+     * When initial local version is given and check, exceptions are thrown if versions mismatch,
+     * or when there is another concurrent process that is already transitioning folder state to new state.
+     * This returns value of new local version.
+     * @param initLocalVersion
+     * @param change
+     */
+    async doChangeWhileTrackingVersion(initLocalVersion, change) {
+        if (initLocalVersion) {
+            if (this.version === initLocalVersion) {
+                return await this.doChange(false, () => this.performTransition(change));
+            }
+            else {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    message: `Given local version ${initLocalVersion} is not equal to current ${this.version}`
+                });
+            }
+        }
+        else {
+            return await this.doChange(true, () => this.performTransition(change));
+        }
+    }
     /**
      * This method prepares a transition state, runs given action, and completes
      * transition to a new version.
@@ -406,6 +476,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const { event, childObjId } = changeEvents;
             this.broadcastEvent(event, false, childObjId);
         }
+        return version;
     }
     /**
      * This function only creates folder node, but it doesn't insert it anywhere.
@@ -894,14 +965,6 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return removedNodes;
     }
     async adoptRemoteFolderItem(remoteItemName, 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 remoteChildNode = await this.getRemoteChildNodeInfo(remoteItemName, opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
         let dstItemName = remoteItemName;
         if (typeof (opts === null || opts === void 0 ? void 0 : opts.newItemName) === 'string') {
@@ -912,15 +975,14 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         const localNodeWithSameName = this.getCurrentNodeInfo(dstItemName, true);
         if (!localNodeWithSameName) {
-            return await this.addRemoteChild(remoteChildNode, dstItemName);
+            return await this.addRemoteChild(remoteChildNode, dstItemName, opts === null || opts === void 0 ? void 0 : opts.localVersion);
         }
         else if (localNodeWithSameName.objId === remoteChildNode.objId) {
-            (0, assert_1.assert)(typeOfNode(localNodeWithSameName) === typeOfNode(remoteChildNode));
             // XXX
             throw new Error(`Adaptation of changing keys needs implementation`);
         }
         else if (opts === null || opts === void 0 ? void 0 : opts.replaceLocalItem) {
-            return await this.replaceLocalChildWithRemote(remoteChildNode);
+            return await this.replaceLocalChildWithRemote(remoteChildNode, opts === null || opts === void 0 ? void 0 : opts.localVersion);
         }
         else {
             throw (0, exceptions_1.makeFSSyncException)(this.name, {
@@ -964,10 +1026,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             });
         }
     }
-    async addRemoteChild(remoteChildNode, childName) {
-        let newVersion;
-        await this.doTransition(async (state, version) => {
-            newVersion = version;
+    addRemoteChild(remoteChildNode, childName, initLocalVersion) {
+        return this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             remoteChildNode.name = childName;
             state.nodes[remoteChildNode.name] = remoteChildNode;
             const event = {
@@ -979,13 +1039,10 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             };
             return { event, childObjId: remoteChildNode.objId };
         });
-        return newVersion;
     }
-    async replaceLocalChildWithRemote(remoteChildNode) {
+    async replaceLocalChildWithRemote(remoteChildNode, initLocalVersion) {
         let origChildNode;
-        let newVersion;
-        await this.doTransition(async (state, version) => {
-            newVersion = version;
+        const newVersion = await this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             origChildNode = state.nodes[remoteChildNode.name];
             state.nodes[remoteChildNode.name] = remoteChildNode;
             const additionEvent = {
@@ -1011,8 +1068,12 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         this.uploadRemovalOfObjs(removalsToUpload);
         return newVersion;
     }
+    async readRemoteVersion(remoteVersion) {
+        const storage = this.syncedStorage();
+        const srcOfRemote = await storage.getObjSrcOfRemoteVersion(this.objId, remoteVersion);
+        return await this.crypto.read(srcOfRemote);
+    }
     async diffCurrentAndRemote(remoteVersion) {
-        var _a;
         const { state, remote } = await this.syncStatus();
         let isCurrentLocal;
         if (state === 'behind') {
@@ -1024,26 +1085,13 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         else {
             return;
         }
-        if (remote.isArchived) {
-            return this.diffWithArchivedRemote(isCurrentLocal);
+        remoteVersion = versionFromRemoteBranch(remote, remoteVersion);
+        if (remoteVersion) {
+            const { folderInfo, attrs, xattrs } = await this.readRemoteVersion(remoteVersion);
+            return this.diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs);
         }
         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);
+            return this.diffWithArchivedRemote(isCurrentLocal);
         }
     }
     diffWithArchivedRemote(isCurrentLocal) {
@@ -1061,7 +1109,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs) {
         const { ctime, mtime } = diffAttrs(this.attrs, attrs);
-        const { inCurrent, inRemote, nameOverlaps } = diffNodes(this.currentState, folderInfo);
+        const { inCurrent, inRemote, nameOverlaps, differentKeys, differentNames } = diffNodes(this.currentState, folderInfo);
         return {
             currentVersion: this.version,
             isCurrentLocal,
@@ -1070,6 +1118,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             inCurrent,
             inRemote,
             nameOverlaps,
+            differentKeys,
+            differentNames,
             ctime,
             mtime,
             xattrs: diffXAttrs(this.xattrs, xattrs)
@@ -1118,20 +1168,6 @@ 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,
@@ -1165,42 +1201,46 @@ function diffAttrs(current, remote) {
     };
 }
 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));
+    const inRemote = [];
+    const nodesInCurrentById = new Map();
+    for (const node of Object.values(current.nodes)) {
+        nodesInCurrentById.set(node.objId, node);
+    }
+    const nameOverlaps = [];
+    const differentNames = [];
+    const differentKeys = [];
+    for (const remoteNode of Object.values(remote.nodes)) {
+        const localNode = nodesInCurrentById.get(remoteNode.objId);
+        if (localNode) {
+            if (localNode.name !== remoteNode.name) {
+                differentNames.push({
+                    localName: localNode.name,
+                    remoteName: remoteNode.name
+                });
+            }
+            if (!areBytesEqual(localNode.key, remoteNode.key)) {
+                differentKeys.push(localNode.name);
+            }
+            nodesInCurrentById.delete(remoteNode.objId);
+        }
+        else {
+            inRemote.push(nodeInfoToListingEntry(remoteNode));
+            if (current.nodes[remoteNode.name]) {
+                nameOverlaps.push(remoteNode.name);
+            }
         }
     }
-    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;
+    const inCurrent = [];
+    for (const localNode of nodesInCurrentById.values()) {
+        inCurrent.push(nodeInfoToListingEntry(localNode));
     }
-    return true;
+    return {
+        inCurrent: ((inCurrent.length > 0) ? inCurrent : undefined),
+        inRemote: ((inRemote.length > 0) ? inRemote : undefined),
+        differentNames: ((differentNames.length > 0) ? differentNames : undefined),
+        nameOverlaps: ((nameOverlaps.length > 0) ? nameOverlaps : undefined),
+        differentKeys: ((differentKeys.length > 0) ? differentKeys : undefined)
+    };
 }
 function combineCheckingNameOverlaps(inCurrent, inRemote) {
     if (inCurrent) {
@@ -1343,4 +1383,22 @@ function identifyChanges(originalNodes, newNodes) {
     }
     return { addedNodes, removedNodes, renamedNodes };
 }
+function versionFromRemoteBranch(remote, remoteVersion) {
+    var _a;
+    if (remote.isArchived) {
+        return;
+    }
+    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 {
+        return remote.latest;
+    }
+}
 Object.freeze(exports);

package/build/lib-client/xsp-fs/fs.d.ts

@@ -28,6 +28,7 @@ type SyncStatus = web3n.files.SyncStatus;
 type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
+type OptionsToAdoptAllRemoteItems = web3n.files.OptionsToAdoptAllRemoteItems;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type FolderDiff = web3n.files.FolderDiff;
 export declare class XspFS implements WritableFS {
@@ -182,5 +183,6 @@ declare class S implements WritableFSSyncAPI {
     listRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ListingEntry[]>;
     getRemoteFileItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFile>;
     getRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFS>;
+    adoptAllRemoteItems(path: string, opts?: OptionsToAdoptAllRemoteItems): Promise<number | undefined>;
 }
 export {};

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022, 2025 - 2026 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -754,14 +754,12 @@ class S {
     }
     async updateStatusInfo(path) {
         const node = await this.n.get(path);
-        const status = await node.updateStatusInfo();
-        return status;
+        return await node.updateStatusInfo();
     }
     async isRemoteVersionOnDisk(path, version) {
         const node = await this.n.get(path);
         try {
-            const isOnDisk = await node.isSyncedVersionOnDisk(version);
-            return isOnDisk;
+            return await node.isSyncedVersionOnDisk(version);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, path);
@@ -795,8 +793,7 @@ class S {
     async diffCurrentAndRemoteFolderVersions(path, remoteVersion) {
         const node = await this.getFolderNode(path);
         try {
-            const diff = await node.diffCurrentAndRemote(remoteVersion);
-            return diff;
+            return await node.diffCurrentAndRemote(remoteVersion);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, path);
@@ -805,8 +802,7 @@ class S {
     async adoptRemoteFolderItem(path, itemName, opts) {
         const node = await this.getFolderNode(path);
         try {
-            const newVersion = await node.adoptRemoteFolderItem(itemName, opts);
-            return newVersion;
+            return await node.adoptRemoteFolderItem(itemName, opts);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, path);
@@ -847,6 +843,10 @@ class S {
             throw (0, file_1.makeFileException)('notDirectory', `${path}/${remoteItemName}`);
         }
     }
+    async adoptAllRemoteItems(path, opts) {
+        const folderNode = await this.getFolderNode(path);
+        return await folderNode.adoptItemsFromRemoteVersion(opts);
+    }
 }
 Object.freeze(S.prototype);
 Object.freeze(S);