core-3nweb-client-lib 0.27.0 → 0.27.4

package/build/core/index.js

@@ -42,17 +42,23 @@ class Core {
         this.closingProc = undefined;
         this.initForNewUser = async (u) => {
             // 1) init of id manager without setting fs
-            const idManager = await id_manager_1.IdManager.initInOneStepWithoutStore(u.address, u.midSKey.default, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-            if (!idManager) {
+            const stepTwo = await id_manager_1.IdManager.initWithoutStore(u.address, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            if (!stepTwo) {
+                throw new Error(`MailerId server doesn't recognize identity ${u.address}`);
+            }
+            // 2) complete id manager login, without use of fs
+            const idManagerInit = await stepTwo(u.midSKey.default);
+            if (!idManagerInit) {
                 throw new Error(`Failed to provision MailerId identity`);
             }
-            // 2) setup storage
-            const storesUp = await this.storages.initFromRemote(u.address, idManager.getSigner, u.storeSKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
+            const { idManager, setupManagerStorage } = idManagerInit;
+            // 3) initialize all storages
+            const storesUp = await this.storages.initFreshForNewUser(u.address, idManager.getSigner, u.storeParams, u.storeSKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
             if (!storesUp) {
                 throw new Error(`Stores failed to initialize`);
             }
             // 3) give id manager fs, in which it will record labeled key(s)
-            await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), [u.midSKey.labeled]);
+            await setupManagerStorage(await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), [u.midSKey.labeled]);
             return idManager;
         };
         this.initForExistingUserWithoutCache = async (address) => {
@@ -63,17 +69,18 @@ class Core {
             }
             return async (midLoginKey, storageKey) => {
                 // 2) complete id manager login, without use of fs
-                const idManager = await stepTwo(midLoginKey);
-                if (!idManager) {
+                const idManagerInit = await stepTwo(midLoginKey);
+                if (!idManagerInit) {
                     return;
                 }
+                const { idManager, setupManagerStorage } = idManagerInit;
                 // 3) initialize all storages
                 const storeDone = await this.storages.initFromRemote(address, idManager.getSigner, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
                 if (!storeDone) {
                     return;
                 }
                 // 4) complete initialization of id manager
-                await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
+                await setupManagerStorage(await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
                 return idManager;
             };
         };
@@ -82,21 +89,12 @@ class Core {
             if (!completeStorageInit) {
                 return;
             }
-            const idManager = await id_manager_1.IdManager.initFromLocalStore(address, await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-            if (idManager) {
-                const res = await completeStorageInit(idManager.getSigner);
-                await idManager.setStorages(undefined, await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
-                return (res ? idManager : undefined);
+            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            if (!idManager) {
+                return;
             }
-            return async (midLoginKey) => {
-                const idManager = await id_manager_1.IdManager.initInOneStepWithoutStore(address, midLoginKey, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
-                if (!idManager) {
-                    return;
-                }
-                const res = await completeStorageInit(idManager.getSigner);
-                await idManager.setStorages(await this.storages.makeLocalFSForApp(MAILERID_APP_NAME), await this.storages.makeSyncedFSForApp(MAILERID_APP_NAME));
-                return (res ? idManager : undefined);
-            };
+            completeStorageInit(idManager.getSigner);
+            return idManager;
         };
         this.closeBroadcast = new rxjs_1.Subject();
         this.close$ = this.closeBroadcast.asObservable();
@@ -112,7 +110,7 @@ class Core {
         return core;
     }
     start() {
-        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, () => this.makeNet(), this.appDirs.getUsersOnDisk, this.logger.logError);
+        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, this.makeNet.bind(this), this.appDirs.getUsersOnDisk, this.logger.logError);
         const signIn = new sign_in_1.SignIn(this.cryptor.cryptor, this.initForExistingUserWithoutCache, this.initForExistingUserWithCache, this.appDirs.getUsersOnDisk, this.logger.logError);
         const capsForStartup = {
             signUp: signUp.exposedService(),
@@ -227,8 +225,7 @@ function makeStoragePolicy(appDomain, requestedCAPs) {
     }
     else if (Array.isArray(capReq.appFS)) {
         const okDomains = capReq.appFS
-            .filter(fsInfo => (fsInfo.domain === appDomain) ||
-            fsInfo.domain.endsWith('.' + appDomain))
+            .filter(fsInfo => (fsInfo.domain === appDomain) || fsInfo.domain.endsWith('.' + appDomain))
             .map(fsInfo => (0, json_utils_1.copy)(fsInfo));
         policy = {
             canOpenAppFS: severalDomainsAppFSChecker(okDomains)

package/build/core/sign-in.d.ts

@@ -6,8 +6,7 @@ import { LogError } from '../lib-client/logging/log-to-file';
 export declare type GenerateKey = (derivParams: ScryptGenParams) => Promise<Uint8Array>;
 export declare type StartInitWithoutCache = (address: string) => Promise<CompleteInitWithoutCache | undefined>;
 export declare type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<IdManager | undefined>;
-export declare type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined | InitTwoWithCache>;
-export declare type InitTwoWithCache = (midLoginKey: GenerateKey) => Promise<IdManager | undefined>;
+export declare type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined>;
 declare type SignInService = web3n.startup.SignInService;
 export declare class SignIn {
     private cryptor;

package/build/core/sign-in.js

@@ -45,7 +45,7 @@ class SignIn {
                 const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
                 const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
                 const storeKeyProgressCB = makeKeyGenProgressCB(51, 100, progressCB);
-                const storeKeyGen = (params) => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
+                const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
                 const idManager = await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
                 if (!idManager) {
                     return false;
@@ -63,23 +63,14 @@ class SignIn {
             try {
                 const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
                 const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const res = await this.initWithCache(user, storeKeyGen);
-                if (!res) {
-                    return false;
-                }
-                if (typeof res === 'object') {
-                    this.doneBroadcast.next(res);
+                const idManager = await this.initWithCache(user, storeKeyGen);
+                if (idManager) {
+                    this.doneBroadcast.next(idManager);
                     return true;
                 }
-                progressCB(49);
-                const midKeyProgressCB = makeKeyGenProgressCB(50, 99, progressCB);
-                const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
-                const idManager = await res(midKeyGen);
-                if (!idManager) {
+                else {
                     return false;
                 }
-                this.doneBroadcast.next(idManager);
-                return true;
             }
             catch (err) {
                 throw await this.logAndWrap(err, 'Failing to start in a state with cache');

package/build/core/sign-up.d.ts

@@ -1,5 +1,6 @@
 import { NetClient } from '../lib-client/request-utils';
 import { JsonKey } from '../lib-common/jwkeys';
+import * as keyDeriv from '../lib-client/key-derivation';
 import { GetUsersOnDisk } from './app-files';
 import { Cryptor } from '../lib-client/cryptor/cryptor';
 import { LogError } from '../lib-client/logging/log-to-file';
@@ -40,5 +41,6 @@ export interface CreatedUser {
         labeled: JsonKey;
     };
     storeSKey: Uint8Array;
+    storeParams: keyDeriv.ScryptGenParams;
 }
 export {};

package/build/core/sign-up.js

@@ -96,7 +96,8 @@ class SignUp {
                     default: this.mid.defaultSKey,
                     labeled: this.mid.labeledSKey
                 },
-                storeSKey: this.store.skey
+                storeSKey: this.store.skey,
+                storeParams: this.store.params.kdParams
             });
             this.forgetKeys();
             return true;

package/build/core/storage/index.d.ts

@@ -2,6 +2,7 @@ import { GetSigner } from '../id-manager';
 import { GenerateKey } from '../sign-in';
 import { StorageGetter } from '../../lib-client/3nstorage/xsp-fs/common';
 import { ServiceLocator } from '../../lib-client/service-locator';
+import { ScryptGenParams } from '../../lib-client/key-derivation';
 import { AsyncSBoxCryptor } from 'xsp-files';
 import { StoragePathForUser } from '../app-files';
 import { LogError } from '../../lib-client/logging/log-to-file';
@@ -30,8 +31,9 @@ export declare class Storages implements FactoryOfFSs {
      * This is a storage getter for links and linking in synced storage.
      */
     private storageGetterForSyncedStorage;
-    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
-    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => void) | undefined>;
+    initFromRemote(user: string, getSigner: GetSigner, generateKey: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    initFreshForNewUser(user: string, getSigner: GetSigner, params: ScryptGenParams, key: Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;
     getUserFS(type: StorageType): Promise<FSItem>;

package/build/core/storage/index.js

@@ -85,20 +85,14 @@ async function readRootKeyDerivParamsFromCache(folder) {
         throw (0, error_1.errWithCause)(err, `Can't read and parse content of obj status file ${KD_PARAMS_FILE_NAME} in folder ${folder}`);
     }
 }
-/**
- * This function tries to get key derivation parameters from cache on a disk.
- * If not found, it will ask storage server for it with a provided function.
- * @param folder
- * @param getFromServer
- */
-async function getRootKeyDerivParams(folder, getFromServer) {
-    let params = await readRootKeyDerivParamsFromCache(folder);
-    if (!params) {
-        params = await getFromServer();
-        await fs.writeFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
-    }
+async function getAndCacheRootKeyDerivParamsFromServer(folder, getFromServer) {
+    const params = await getFromServer();
+    await saveRootKeyDerivParamsToDisk(folder, params);
     return params;
 }
+async function saveRootKeyDerivParamsToDisk(folder, params) {
+    await fs.writeFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
+}
 class StorageAndFS {
     constructor(storage) {
         this.storage = storage;
@@ -125,32 +119,15 @@ class StorageAndFS {
             }
         }
     }
-    static async newOrExisting(storage, key) {
-        var _a, _b;
+    static async makeNew(storage, key) {
+        var _a;
         const s = new StorageAndFS(storage);
-        try {
-            s.rootFS = await fs_1.XspFS.fromExistingRoot(s.storage, key);
-            if ((_a = s.rootFS.v) === null || _a === void 0 ? void 0 : _a.sync) {
-                s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
-            }
-            return s;
-        }
-        catch (err) {
-            if (err.objNotFound) {
-                s.rootFS = await fs_1.XspFS.makeNewRoot(s.storage, key);
-                await (0, system_folders_1.initSysFolders)(s.rootFS);
-                if ((_b = s.rootFS.v) === null || _b === void 0 ? void 0 : _b.sync) {
-                    s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
-                }
-                return s;
-            }
-            else if (err.failedCipherVerification) {
-                return;
-            }
-            else {
-                throw err;
-            }
+        s.rootFS = await fs_1.XspFS.makeNewRoot(s.storage, key);
+        await (0, system_folders_1.initSysFolders)(s.rootFS);
+        if ((_a = s.rootFS.v) === null || _a === void 0 ? void 0 : _a.sync) {
+            s.syncedAppDataRoots = await apps_data_1.AppDataFolders.make(s.rootFS);
         }
+        return s;
     }
     /**
      * This creates app data folder.
@@ -278,30 +255,32 @@ class Storages {
         if (!this.local) {
             return;
         }
-        return async (getSigner) => {
-            if (this.synced) {
-                return true;
-            }
-            const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
-            this.synced = await StorageAndFS.existing(syncedStore, key);
-            key.fill(0);
-            if (!this.synced) {
-                return false;
-            }
-            startObjProcs();
-            return true;
-        };
+        const { syncedStore, setupRemoteAndStartObjProcs } = await storage_1.SyncedStore.makeAndStartWithoutRemote((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
+        this.synced = await StorageAndFS.existing(syncedStore, key);
+        key.fill(0);
+        if (!this.synced) {
+            return;
+        }
+        return setupRemoteAndStartObjProcs;
+    }
+    async initFromRemote(user, getSigner, generateKey, makeNet, resolver, logError) {
+        const storageDir = this.storageDirForUser(user);
+        const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
+        const params = await getAndCacheRootKeyDerivParamsFromServer(storageDir, syncedStore.getRootKeyDerivParamsFromServer);
+        const key = await generateKey(params);
+        this.synced = await StorageAndFS.existing(syncedStore, key);
+        this.local = await StorageAndFS.makeNew(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
+        key.fill(0);
+        startObjProcs();
+        return (!!this.synced && !!this.local);
     }
-    async initFromRemote(user, getSigner, keyOrGen, makeNet, resolver, logError) {
+    async initFreshForNewUser(user, getSigner, params, key, makeNet, resolver, logError) {
         const storageDir = this.storageDirForUser(user);
         const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart((0, path_1.join)(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet(), logError);
-        // getting parameters records them locally on a disk
-        const params = await getRootKeyDerivParams(storageDir, syncedStore.getRootKeyDerivParamsFromServer);
-        const key = ((typeof keyOrGen === 'function') ?
-            await keyOrGen(params) : keyOrGen);
-        this.synced = await StorageAndFS.newOrExisting(syncedStore, key);
-        this.local = await StorageAndFS.newOrExisting(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
+        this.synced = await StorageAndFS.makeNew(syncedStore, key);
+        this.local = await StorageAndFS.makeNew(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
         key.fill(0);
+        await saveRootKeyDerivParamsToDisk(storageDir, params);
         startObjProcs();
         return (!!this.synced && !!this.local);
     }
@@ -523,7 +502,7 @@ async function applyPolicyToFSCollection(c, policy, path) {
     }
     const nameAndItem = await (0, async_iter_1.asyncFind)(await c.entries(), async (v) => path.startsWith(v[0]));
     if (!nameAndItem) {
-        throw (0, file_1.makeFileException)(file_1.Code.notFound, path);
+        throw (0, file_1.makeFileException)('notFound', path);
     }
     const [name, item] = nameAndItem;
     path = path.substring(name.length);

package/build/core/storage/local/storage.d.ts

@@ -9,7 +9,7 @@ export declare class LocalStorage implements Storage {
     private readonly files;
     private readonly getStorages;
     readonly cryptor: AsyncSBoxCryptor;
-    private readonly logError;
+    readonly logError: LogError;
     readonly type = "local";
     readonly versioned = true;
     readonly nodes: NodesContainer;

package/build/core/storage/synced/obj-files-gc.d.ts

@@ -1,10 +1,8 @@
 import { SynchronizerOnObjId, SyncedObj } from './obj-files';
-import { StorageOwner as RemoteStorage } from '../../../lib-client/3nstorage/service';
 export declare class GC {
     private readonly sync;
     private readonly rmObjFromCache;
     private readonly rmObjFolder;
-    private readonly remote;
     private isStopped;
     /**
      * All gc steps are done in this process.
@@ -20,11 +18,10 @@ export declare class GC {
      * with wip set.
      */
     private scheduled;
-    constructor(sync: SynchronizerOnObjId, rmObjFromCache: (obj: SyncedObj) => void, rmObjFolder: (objId: string) => Promise<void>, remote: RemoteStorage);
+    constructor(sync: SynchronizerOnObjId, rmObjFromCache: (obj: SyncedObj) => void, rmObjFolder: (objId: string) => Promise<void>);
     scheduleCollection: (obj: SyncedObj) => void;
     stop(): Promise<void>;
     private objCollecting;
     private collectIn;
-    private upsyncObjRemovalWhenNeeded;
     private checkAndRemoveWholeObjFolder;
 }

package/build/core/storage/synced/obj-files-gc.js

@@ -24,11 +24,10 @@ const path_1 = require("path");
 const utils_1 = require("../common/utils");
 const upload_header_file_1 = require("./upload-header-file");
 class GC {
-    constructor(sync, rmObjFromCache, rmObjFolder, remote) {
+    constructor(sync, rmObjFromCache, rmObjFolder) {
         this.sync = sync;
         this.rmObjFromCache = rmObjFromCache;
         this.rmObjFolder = rmObjFolder;
-        this.remote = remote;
         this.isStopped = false;
         /**
          * All gc steps are done in this process.
@@ -71,27 +70,11 @@ class GC {
         this.isStopped = true;
     }
     async collectIn(obj) {
-        if (obj.statusObj().isArchived()) {
-            await this.upsyncObjRemovalWhenNeeded(obj);
-        }
         const nonGarbage = obj.statusObj().getNonGarbageVersions();
         if (!(await this.checkAndRemoveWholeObjFolder(obj, nonGarbage))) {
             await removeGarbageFiles(obj, nonGarbage);
         }
     }
-    async upsyncObjRemovalWhenNeeded(obj) {
-        if (!needsUpsyncOfRemoval(obj)) {
-            return;
-        }
-        try {
-            await this.remote.deleteObj(obj.objId);
-        }
-        catch (exc) {
-            // XXX will need to schedule other attempt to delete on remote
-            return;
-        }
-        await obj.statusObj().recordSyncOfObjRemoval();
-    }
     async checkAndRemoveWholeObjFolder(obj, { local, remote }) {
         if (obj.objId
             && obj.statusObj().isArchived()

package/build/core/storage/synced/obj-files.d.ts

@@ -13,6 +13,12 @@ import { StorageOwner as RemoteStorage } from '../../../lib-client/3nstorage/ser
 import { UploadHeaderChange } from '../../../lib-client/3nstorage/xsp-fs/common';
 export declare const UNSYNCED_FILE_NAME_EXT = "unsynced";
 export declare const REMOTE_FILE_NAME_EXT = "v";
+/**
+ * File system has nodes. Each node may have data in one or many objects of
+ * storage. SyncedObj allows to work with files of storage object, even when
+ * file system node no longer exists. ObjFiles is a holder and factory of
+ * SyncedObj's.
+ */
 export declare class ObjFiles {
     private readonly folders;
     private readonly logError;
@@ -22,6 +28,7 @@ export declare class ObjFiles {
     private readonly gc;
     private constructor();
     static makeFor(path: string, remote: RemoteStorage, logError: LogError): Promise<ObjFiles>;
+    private canMoveObjToDeeperCache;
     findObj(objId: ObjId): Promise<SyncedObj | undefined>;
     getObjInCache(objId: ObjId): SyncedObj | undefined;
     private makeObj;
@@ -31,7 +38,7 @@ export declare class ObjFiles {
         fileWrite$: Observable<FileWrite[]>;
         newObj: SyncedObj;
     }>;
-    findUnsyncedObjs(): Observable<ObjId>;
+    findObjsToRemoveOnRemote(): Observable<ObjId>;
     scheduleGC(obj: SyncedObj): void;
 }
 export declare type SynchronizerOnObjId = <T>(objId: ObjId, action: () => Promise<T>) => Promise<T>;
@@ -81,4 +88,7 @@ export declare class SyncedObj {
     }>;
     syncStatus(): SyncedObjStatus;
     statusObj(): ObjStatus;
+    recordRemovalUploadAndGC(): Promise<void>;
+    isRemoteVersionOnDisk(version: number): Promise<'complete' | 'partial' | 'none'>;
+    downloadRemoteVersion(version: number): Promise<void>;
 }

package/build/core/storage/synced/obj-files.js

@@ -19,7 +19,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncedObj = exports.ObjFiles = exports.REMOTE_FILE_NAME_EXT = exports.UNSYNCED_FILE_NAME_EXT = void 0;
 const rxjs_1 = require("rxjs");
 const synced_1 = require("../../../lib-common/processes/synced");
-const sleep_1 = require("../../../lib-common/processes/sleep");
 const obj_folders_1 = require("../../../lib-client/objs-on-disk/obj-folders");
 const fs = require("../../../lib-common/async-fs-node");
 const obj_on_disk_1 = require("../../../lib-client/objs-on-disk/obj-on-disk");
@@ -33,8 +32,15 @@ const obj_status_1 = require("./obj-status");
 const timed_cache_1 = require("../../../lib-common/timed-cache");
 const upload_header_file_1 = require("./upload-header-file");
 const utils_1 = require("../common/utils");
+const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
 exports.UNSYNCED_FILE_NAME_EXT = 'unsynced';
 exports.REMOTE_FILE_NAME_EXT = 'v';
+/**
+ * File system has nodes. Each node may have data in one or many objects of
+ * storage. SyncedObj allows to work with files of storage object, even when
+ * file system node no longer exists. ObjFiles is a holder and factory of
+ * SyncedObj's.
+ */
 class ObjFiles {
     constructor(folders, remote, logError) {
         this.folders = folders;
@@ -46,31 +52,32 @@ class ObjFiles {
             if (this.objs.get(obj.objId) === obj) {
                 this.objs.delete(obj.objId);
             }
-        }, objId => this.folders.removeFolderOf(objId), remote);
+        }, objId => this.folders.removeFolderOf(objId));
         Object.freeze(this);
     }
     static async makeFor(path, remote, logError) {
-        const canMove = async (objId, objFolderPath) => {
-            if (objFiles.objs.has(objId)) {
-                return false;
-            }
-            const lst = await fs.readdir(objFolderPath);
-            for (const fName of lst) {
-                if (fName.endsWith(exports.UNSYNCED_FILE_NAME_EXT)) {
-                    return false;
-                }
-            }
-            try {
-                return (await obj_status_1.ObjStatus.fileShowsObjNotInSyncedState(objFolderPath, objId));
-            }
-            catch (exc) {
-                return false;
-            }
-        };
+        const canMove = (objId, objFolderPath) => objFiles.canMoveObjToDeeperCache(objId, objFolderPath);
         const folders = await obj_folders_1.ObjFolders.makeWithGenerations(path, canMove, logError);
         const objFiles = new ObjFiles(folders, remote, logError);
         return objFiles;
     }
+    async canMoveObjToDeeperCache(objId, objFolderPath) {
+        if (this.objs.has(objId)) {
+            return false;
+        }
+        const lst = await fs.readdir(objFolderPath);
+        for (const fName of lst) {
+            if (fName.endsWith(exports.UNSYNCED_FILE_NAME_EXT)) {
+                return false;
+            }
+        }
+        try {
+            return (await obj_status_1.ObjStatus.fileShowsObjNotInSyncedState(objFolderPath, objId));
+        }
+        catch (exc) {
+            return false;
+        }
+    }
     async findObj(objId) {
         let obj = this.objs.get(objId);
         if (obj) {
@@ -131,25 +138,23 @@ class ObjFiles {
             .pipe((0, utils_for_observables_1.flatTap)(undefined, err => this.removeFailedNewObj(newObj)));
         return { fileWrite$, newObj };
     }
-    findUnsyncedObjs() {
+    findObjsToRemoveOnRemote() {
         return (0, rxjs_1.from)([undefined])
             .pipe(
         // listing recent folders, exactly once
         (0, operators_1.mergeMap)(() => this.folders.listRecent()), 
         // flatten array and space it in time, to process folders one by one
-        (0, operators_1.mergeMap)(objsAndPaths => objsAndPaths), (0, operators_1.filter)(({ objId }) => !this.objs.has(objId)), (0, operators_1.mergeMap)(async (objsAndPaths) => {
-            await (0, sleep_1.sleep)(20);
-            return objsAndPaths;
-        }, 1), 
-        // check, emiting objId, if not synced, and undefined, if synced
-        (0, operators_1.mergeMap)(({ path, objId }) => this.sync(objId, async () => {
-            if (this.objs.has(objId)) {
-                return;
+        (0, operators_1.mergeMap)(objsAndPaths => objsAndPaths), (0, operators_1.mergeMap)(async ({ objId, path }) => {
+            const obj = this.objs.get(objId);
+            if (obj) {
+                return (obj.statusObj().needsRemovalOnRemote() ?
+                    objId : undefined);
             }
-            const notSynced = await obj_status_1.ObjStatus.fileShowsObjNotInSyncedState(path, objId)
-                .catch(notFoundOrReThrow).catch(this.logError);
-            return (notSynced ? objId : undefined);
-        })), (0, operators_1.filter)(objId => (objId !== undefined)));
+            else {
+                const needsRm = await obj_status_1.ObjStatus.fileShowsObjNeedsRemovalOnRemote(path, objId);
+                return (needsRm ? objId : undefined);
+            }
+        }, 1), (0, operators_1.filter)(objId => (objId !== undefined)));
     }
     scheduleGC(obj) {
         this.gc.scheduleCollection(obj);
@@ -334,9 +339,10 @@ class SyncedObj {
             this.remoteVers.set(uploadVersion, syncedVerObj);
         }
         else {
-            await fs.rename(this.localVerPath(localVersion), remotePath);
+            const localPath = this.localVerPath(localVersion);
+            await fs.rename(localPath, remotePath);
         }
-        await this.status.markLocalVersionSynced(localVersion, uploadVersion);
+        await this.status.recordUploadCompletion(localVersion, uploadVersion);
         this.scheduleSelfGC();
     }
     dropCachedLocalObjVersionsLessOrEqual(version) {
@@ -387,6 +393,25 @@ class SyncedObj {
     statusObj() {
         return this.status;
     }
+    async recordRemovalUploadAndGC() {
+        await this.status.recordRemoteRemovalCompletion();
+        this.scheduleSelfGC();
+    }
+    async isRemoteVersionOnDisk(version) {
+        if (!this.status.isAmongRemote(version)) {
+            throw (0, exceptions_1.makeObjVersionNotFoundExc)(this.objId, version);
+        }
+        const verPath = this.remoteVerPath(version);
+        if (!(await isOnDisk(verPath))) {
+            return 'none';
+        }
+        const objVer = await this.instanceOfRemoteObjVer(version);
+        return (objVer.doesFileNeedDownload() ? 'complete' : 'partial');
+    }
+    async downloadRemoteVersion(version) {
+        const objVer = await this.instanceOfRemoteObjVer(version);
+        await objVer.downloadMissingSections();
+    }
 }
 exports.SyncedObj = SyncedObj;
 Object.freeze(SyncedObj.prototype);