core-3nweb-client-lib 0.25.6 → 0.27.0

package/build/core/storage/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2017, 2019 - 2021 3NSoft Inc.
+ Copyright (C) 2015 - 2017, 2019 - 2022 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
@@ -16,17 +16,18 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerAppStorage = exports.reverseDomain = exports.sysFilesOnDevice = exports.userFilesOnDevice = exports.Storages = exports.initSysFolders = exports.sysFolders = void 0;
+exports.PerAppStorage = exports.reverseDomain = exports.Storages = void 0;
 const fs_1 = require("../../lib-client/3nstorage/xsp-fs/fs");
 const storage_1 = require("./synced/storage");
 const storage_2 = require("./local/storage");
 const file_1 = require("../../lib-common/exceptions/file");
 const fs_collection_1 = require("../../lib-client/fs-collection");
 const async_iter_1 = require("../../lib-common/async-iter");
-const device_fs_1 = require("../../lib-client/local-files/device-fs");
 const path_1 = require("path");
 const fs = require("../../lib-common/async-fs-node");
 const error_1 = require("../../lib-common/exceptions/error");
+const system_folders_1 = require("./system-folders");
+const apps_data_1 = require("./system-folders/apps-data");
 function makeBadAppNameExc(appName) {
     return {
         runtimeException: true,
@@ -74,58 +75,45 @@ const SYNCED_STORAGE_DIR = 'synced';
  */
 async function readRootKeyDerivParamsFromCache(folder) {
     try {
-        const str = await fs.readFile(path_1.join(folder, KD_PARAMS_FILE_NAME), { encoding: 'utf8' });
+        const str = await fs.readFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), { encoding: 'utf8' });
         return JSON.parse(str);
     }
     catch (err) {
         if (err.notFound) {
             return undefined;
         }
-        throw error_1.errWithCause(err, `Can't read and parse content of obj status file ${KD_PARAMS_FILE_NAME} in folder ${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 fs
+ * @param folder
  * @param getFromServer
  */
 async function getRootKeyDerivParams(folder, getFromServer) {
     let params = await readRootKeyDerivParamsFromCache(folder);
     if (!params) {
         params = await getFromServer();
-        await fs.writeFile(path_1.join(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
+        await fs.writeFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
     }
     return params;
 }
-exports.sysFolders = {
-    appData: 'Apps Data',
-    apps: 'Apps Code',
-    packages: 'App&Lib Packs',
-    sharedLibs: 'Shared Libs',
-    userFiles: 'User Files'
-};
-Object.freeze(exports.sysFolders);
-/**
- * This function creates initial folder structure in a given root.
- * @param root
- */
-async function initSysFolders(root) {
-    for (const sysFolder of Object.values(exports.sysFolders)) {
-        await root.makeFolder(sysFolder);
-    }
-}
-exports.initSysFolders = initSysFolders;
 class StorageAndFS {
     constructor(storage) {
         this.storage = storage;
         this.rootFS = undefined;
+        this.syncedAppDataRoots = undefined;
         Object.seal(this);
     }
     static async existing(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) {
@@ -138,15 +126,22 @@ class StorageAndFS {
         }
     }
     static async newOrExisting(storage, key) {
+        var _a, _b;
         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 initSysFolders(s.rootFS);
+                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) {
@@ -157,27 +152,35 @@ class StorageAndFS {
             }
         }
     }
-    makeAppFS(appFolder) {
-        if (('string' !== typeof appFolder) ||
-            (appFolder.length === 0) ||
-            (appFolder.indexOf('/') >= 0)) {
+    /**
+     * This creates app data folder.
+     * Folder objects are uploaded, if this is a synced storage.
+     * @param appFolder
+     */
+    async makeAppFS(appFolder) {
+        if (('string' !== typeof appFolder) || (appFolder.length === 0)
+            || (appFolder.indexOf('/') >= 0)
+            || (appFolder === '.') || (appFolder === '..')) {
             throw makeBadAppNameExc(appFolder);
         }
         if (!this.rootFS) {
             throw new Error('Storage is not initialized.');
         }
-        return this.rootFS.writableSubRoot(`${exports.sysFolders.appData}/${appFolder}`);
+        const appDataFS = await (this.syncedAppDataRoots ?
+            this.syncedAppDataRoots.getOrMake(appFolder) :
+            this.rootFS.writableSubRoot(`${system_folders_1.sysFolders.appData}/${appFolder}`));
+        return appDataFS;
     }
     userFS() {
-        return this.rootFS.writableSubRoot(exports.sysFolders.userFiles);
+        return this.rootFS.writableSubRoot(system_folders_1.sysFolders.userFiles);
     }
     async sysFSs() {
         const folders = [
-            exports.sysFolders.appData, exports.sysFolders.apps,
-            exports.sysFolders.packages,
-            exports.sysFolders.sharedLibs
+            system_folders_1.sysFolders.appData, system_folders_1.sysFolders.apps,
+            system_folders_1.sysFolders.packages,
+            system_folders_1.sysFolders.sharedLibs
         ];
-        const c = fs_collection_1.makeFSCollection();
+        const c = (0, fs_collection_1.makeFSCollection)();
         for (let fsName of folders) {
             await c.set(fsName, {
                 isFolder: true,
@@ -187,15 +190,20 @@ class StorageAndFS {
         return c;
     }
     async close() {
+        var _a;
         if (!this.rootFS) {
             return;
         }
+        (_a = this.syncedAppDataRoots) === null || _a === void 0 ? void 0 : _a.stopSync();
         await this.rootFS.close();
         await this.storage.close();
+        this.syncedAppDataRoots = undefined;
         this.rootFS = undefined;
         this.storage = undefined;
     }
 }
+Object.freeze(StorageAndFS.prototype);
+Object.freeze(StorageAndFS);
 class Storages {
     constructor(cryptor, storageDirForUser) {
         this.cryptor = cryptor;
@@ -266,7 +274,7 @@ class Storages {
             return;
         }
         const key = await keyGen(params);
-        this.local = await StorageAndFS.existing(await storage_2.LocalStorage.makeAndStart(path_1.join(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
+        this.local = await StorageAndFS.existing(await storage_2.LocalStorage.makeAndStart((0, path_1.join)(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), key);
         if (!this.local) {
             return;
         }
@@ -274,25 +282,25 @@ class Storages {
             if (this.synced) {
                 return true;
             }
-            const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart(path_1.join(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet, logError);
+            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;
             }
-            await startObjProcs();
+            startObjProcs();
             return true;
         };
     }
     async initFromRemote(user, getSigner, keyOrGen, makeNet, resolver, logError) {
         const storageDir = this.storageDirForUser(user);
-        const { startObjProcs, syncedStore } = await storage_1.SyncedStore.makeAndStart(path_1.join(storageDir, SYNCED_STORAGE_DIR), user, getSigner, this.storageGetterForSyncedStorage, this.cryptor, () => resolver(user), makeNet, logError);
+        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(path_1.join(storageDir, LOCAL_STORAGE_DIR), this.storageGetterForLocalStorage, this.cryptor, logError), 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);
         key.fill(0);
         startObjProcs();
         return (!!this.synced && !!this.local);
@@ -316,7 +324,7 @@ class Storages {
             fs = await this.local.userFS();
         }
         else if (type === 'device') {
-            fs = await userFilesOnDevice();
+            fs = await (0, system_folders_1.userFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -342,7 +350,7 @@ class Storages {
             };
         }
         else if (type === 'device') {
-            return sysFilesOnDevice();
+            return (0, system_folders_1.sysFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -372,33 +380,6 @@ class Storages {
 exports.Storages = Storages;
 Object.freeze(Storages.prototype);
 Object.freeze(Storages);
-async function userFilesOnDevice() {
-    if (process.platform === 'win32') {
-        return device_fs_1.DeviceFS.makeWritable(process.env.USERPROFILE);
-    }
-    else {
-        return device_fs_1.DeviceFS.makeWritable(process.env.HOME);
-    }
-}
-exports.userFilesOnDevice = userFilesOnDevice;
-async function sysFilesOnDevice() {
-    const c = fs_collection_1.makeFSCollection();
-    if (process.platform === 'win32') {
-        const sysDrive = process.env.SystemDrive;
-        await c.set(sysDrive, {
-            isFolder: true,
-            item: await device_fs_1.DeviceFS.makeWritable(sysDrive)
-        });
-    }
-    else {
-        await c.set('', {
-            isFolder: true,
-            item: await device_fs_1.DeviceFS.makeWritable('/')
-        });
-    }
-    return { isCollection: true, item: c };
-}
-exports.sysFilesOnDevice = sysFilesOnDevice;
 function reverseDomain(domain) {
     return domain.split('.').reverse().join('.');
 }
@@ -456,8 +437,7 @@ class PerAppStorage {
         if (typeof appFolder !== 'string') {
             throw makeBadAppNameExc(appFolder);
         }
-        if (CORE_APPS_PREFIX ===
-            appFolder.substring(0, CORE_APPS_PREFIX.length)) {
+        if (appFolder.startsWith(CORE_APPS_PREFIX)) {
             throw makeNotAllowedToOpenAppFSExc(appFolder);
         }
         if (!this.policy.canOpenAppFS(appFolder, type)) {
@@ -523,10 +503,10 @@ async function applyPolicyToFS(fs, policy, path) {
 async function applyPolicyToFSCollection(c, policy, path) {
     if (path === undefined) {
         if (policy === 'w') {
-            return fs_collection_1.readonlyWrapFSCollection(c);
+            return (0, fs_collection_1.readonlyWrapFSCollection)(c);
         }
         else {
-            const roFSs = fs_collection_1.makeFSCollection();
+            const roFSs = (0, fs_collection_1.makeFSCollection)();
             for (const v of (await c.getAll())) {
                 const fs = v[1].item;
                 if (!v[1].isFolder || !fs || !fs.listFolder) {
@@ -535,15 +515,15 @@ async function applyPolicyToFSCollection(c, policy, path) {
                 v[1].item = await v[1].item.readonlySubRoot('/');
                 await roFSs.set(v[0], v[1]);
             }
-            return fs_collection_1.readonlyWrapFSCollection(roFSs);
+            return (0, fs_collection_1.readonlyWrapFSCollection)(roFSs);
         }
     }
     if (path.startsWith('/')) {
         path = path.substring(1);
     }
-    const nameAndItem = await async_iter_1.asyncFind(await c.entries(), async (v) => path.startsWith(v[0]));
+    const nameAndItem = await (0, async_iter_1.asyncFind)(await c.entries(), async (v) => path.startsWith(v[0]));
     if (!nameAndItem) {
-        throw file_1.makeFileException(file_1.Code.notFound, path);
+        throw (0, file_1.makeFileException)(file_1.Code.notFound, path);
     }
     const [name, item] = nameAndItem;
     path = path.substring(name.length);

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

@@ -19,4 +19,6 @@ export declare class GC {
     constructor(rmObjFromCache: (obj: LocalObj) => void, rmObjFolder: (objId: string) => Promise<void>);
     scheduleCollection: (obj: LocalObj) => void;
     private objCollecting;
+    private collectIn;
+    private checkAndRemoveWholeObjFolder;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2020 3NSoft Inc.
+ Copyright (C) 2016 - 2020, 2022 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
@@ -13,12 +13,14 @@
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GC = void 0;
 const fs = require("../../../lib-common/async-fs-node");
-const processes_1 = require("../../../lib-common/processes");
+const synced_1 = require("../../../lib-common/processes/synced");
 const path_1 = require("path");
+const utils_1 = require("../common/utils");
 class GC {
     constructor(rmObjFromCache, rmObjFolder) {
         this.rmObjFromCache = rmObjFromCache;
@@ -26,7 +28,7 @@ class GC {
         /**
          * All gc steps are done in this process.
          */
-        this.gcProc = new processes_1.SingleProc();
+        this.gcProc = new synced_1.SingleProc();
         /**
          * wip are objects that are currently processed. When wip set is empty,
          * it gets swapped with non-empty scheduled set.
@@ -48,53 +50,65 @@ class GC {
             if (this.wip.size === 0) {
                 [this.wip, this.scheduled] = [this.scheduled, this.wip];
             }
-            const obj = getAndRemoveOneFrom(this.wip);
+            const obj = (0, utils_1.getAndRemoveOneFrom)(this.wip);
             if (!obj) {
                 return;
             }
-            // calculate versions that should not be removed
-            const { gcMaxVer, nonGarbage } = obj.getNonGarbageVersions();
-            // if object is set archived, and there is nothing in it worth keeping,
-            // whole folder can be removed
-            if (obj.isArchived()) {
-                if (nonGarbage.size === 0) {
-                    this.rmObjFromCache(obj);
-                    if (obj.objId) {
-                        await this.rmObjFolder(obj.objId);
-                    }
-                    return;
-                }
-            }
-            // for all other cases, we remove version files that are not worth
-            // keeping.
-            const lst = await fs.readdir(obj.objFolder);
-            const rmProcs = [];
-            for (const f of lst) {
-                const ver = parseInt(f);
-                if (isNaN(ver) || nonGarbage.has(ver)
-                    || (gcMaxVer && (ver >= gcMaxVer))) {
-                    continue;
-                }
-                rmProcs.push(fs.unlink(path_1.join(obj.objFolder, f)).catch(() => { }));
-            }
-            while (rmProcs.length > 0) {
-                await rmProcs.pop();
+            try {
+                await this.collectIn(obj);
             }
+            catch (err) { }
             return this.objCollecting();
         };
         Object.seal(this);
     }
+    async collectIn(obj) {
+        const nonGarbage = obj.statusObj().getNonGarbageVersions();
+        if (!(await this.checkAndRemoveWholeObjFolder(obj, nonGarbage))) {
+            await removeGarbageFiles(obj, nonGarbage);
+        }
+    }
+    async checkAndRemoveWholeObjFolder(obj, { nonGarbage }) {
+        // if object is set archived, and there is nothing in it worth keeping,
+        // whole folder can be removed
+        if (obj.objId
+            && obj.statusObj().isArchived()
+            && (nonGarbage.size === 0)) {
+            this.rmObjFromCache(obj);
+            await this.rmObjFolder(obj.objId);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
 }
 exports.GC = GC;
 Object.freeze(GC.prototype);
 Object.freeze(GC);
-function getAndRemoveOneFrom(set) {
-    const iter = set.values();
-    const { value, done } = iter.next();
-    if (done) {
-        return;
+async function removeGarbageFiles(obj, nonGarbage) {
+    const lst = await fs.readdir(obj.objFolder);
+    const rmProcs = [];
+    for (const f of lst) {
+        if (canGC(f, nonGarbage)) {
+            rmProcs.push(fs.unlink((0, path_1.join)(obj.objFolder, f)).catch(utils_1.noop));
+        }
+    }
+    if (rmProcs.length > 0) {
+        await Promise.all(rmProcs);
+    }
+}
+function canGC(f, { gcMaxVer, nonGarbage }) {
+    const ver = parseInt(f);
+    if (isNaN(ver)) {
+        return false;
+    }
+    else if (!nonGarbage.has(ver)
+        && (!gcMaxVer || (ver < gcMaxVer))) {
+        return true;
+    }
+    else {
+        return false;
     }
-    set.delete(value);
-    return value;
 }
 Object.freeze(exports);

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

@@ -1,6 +1,7 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { LocalObjStatus, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
 import { ObjSource, Subscribe } from 'xsp-files';
 import { GC } from './obj-files-gc';
+import { ObjStatus } from './obj-status';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 export declare class ObjFiles {
     private readonly folders;
@@ -23,18 +24,14 @@ export declare class LocalObj {
     private readonly scheduleGC;
     private readonly verObjs;
     private constructor();
-    static forExistingObj(objId: ObjId, objFolder: string, scheduleGC: GC['scheduleCollection']): Promise<LocalObj>;
-    static forNewObj(objId: ObjId, objFolder: string, scheduleGC: GC['scheduleCollection']): Promise<LocalObj>;
+    static forExistingObj(objId: ObjId, objFolder: string, scheduleGC: GC['scheduleCollection'], logError: LogError | undefined): Promise<LocalObj>;
+    static forNewObj(objId: ObjId, objFolder: string, scheduleGC: GC['scheduleCollection'], logError: LogError | undefined): Promise<LocalObj>;
     private path;
     getObjSrc(version: number): Promise<ObjSource>;
     private objSegsGetterFromDisk;
     saveNewVersion(version: number, encSub: Subscribe): Promise<void>;
-    isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer: number | undefined;
-        nonGarbage: Set<number>;
-    };
+    localStatus(): LocalObjStatus;
+    statusObj(): ObjStatus;
     removeCurrentVersion(): Promise<void>;
     removeArchivedVersion(version: number): Promise<void>;
 }

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2020 3NSoft Inc.
+ Copyright (C) 2016 - 2020, 2022 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
@@ -19,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalObj = exports.ObjFiles = void 0;
 const obj_folders_1 = require("../../../lib-client/objs-on-disk/obj-folders");
 const obj_on_disk_1 = require("../../../lib-client/objs-on-disk/obj-on-disk");
-const processes_1 = require("../../../lib-common/processes");
+const synced_1 = require("../../../lib-common/processes/synced");
 const path_1 = require("path");
 const obj_files_gc_1 = require("./obj-files-gc");
 const obj_status_1 = require("./obj-status");
@@ -28,8 +28,8 @@ class ObjFiles {
     constructor(folders, logError) {
         this.folders = folders;
         this.logError = logError;
-        this.objs = timed_cache_1.makeTimedCache(60 * 1000);
-        this.folderAccessSyncProc = new processes_1.NamedProcs();
+        this.objs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
+        this.folderAccessSyncProc = new synced_1.NamedProcs();
         this.gc = new obj_files_gc_1.GC(obj => {
             if (this.objs.get(obj.objId) === obj) {
                 this.objs.delete(obj.objId);
@@ -55,7 +55,7 @@ class ObjFiles {
             if (!folder) {
                 return;
             }
-            obj = await LocalObj.forExistingObj(objId, folder, this.gc.scheduleCollection);
+            obj = await LocalObj.forExistingObj(objId, folder, this.gc.scheduleCollection, this.logError);
             this.objs.set(objId, obj);
             return obj;
         });
@@ -63,7 +63,7 @@ class ObjFiles {
     async makeNewObj(objId) {
         return this.sync(objId, async () => {
             const folder = await this.folders.getFolderAccessFor(objId, true);
-            const obj = await LocalObj.forNewObj(objId, folder, this.gc.scheduleCollection);
+            const obj = await LocalObj.forNewObj(objId, folder, this.gc.scheduleCollection, this.logError);
             this.objs.set(objId, obj);
             return obj;
         });
@@ -99,7 +99,7 @@ class LocalObj {
         this.objFolder = objFolder;
         this.status = status;
         this.scheduleGC = scheduleGC;
-        this.verObjs = timed_cache_1.makeTimedCache(60 * 1000);
+        this.verObjs = (0, timed_cache_1.makeTimedCache)(60 * 1000);
         this.objSegsGetterFromDisk = async (ver, ofs, len) => {
             let obj = this.verObjs.get(ver);
             if (!obj) {
@@ -111,16 +111,16 @@ class LocalObj {
         };
         Object.freeze(this);
     }
-    static async forExistingObj(objId, objFolder, scheduleGC) {
-        const status = await obj_status_1.ObjStatus.readFrom(objFolder, objId);
+    static async forExistingObj(objId, objFolder, scheduleGC, logError) {
+        const status = await obj_status_1.ObjStatus.readFrom(objFolder, objId, logError);
         return new LocalObj(objId, objFolder, status, scheduleGC);
     }
-    static async forNewObj(objId, objFolder, scheduleGC) {
-        const status = await obj_status_1.ObjStatus.makeNew(objFolder, objId);
+    static async forNewObj(objId, objFolder, scheduleGC, logError) {
+        const status = await obj_status_1.ObjStatus.makeNew(objFolder, objId, logError);
         return new LocalObj(objId, objFolder, status, scheduleGC);
     }
     path(version) {
-        return path_1.join(this.objFolder, `${version}.v`);
+        return (0, path_1.join)(this.objFolder, `${version}.v`);
     }
     async getObjSrc(version) {
         let obj = this.verObjs.get(version);
@@ -152,14 +152,11 @@ class LocalObj {
         await this.status.setNewCurrentVersion(version, obj.getBaseVersion());
         this.scheduleGC(this);
     }
-    isArchived() {
-        return this.status.isArchived();
+    localStatus() {
+        return this.status;
     }
-    getCurrentVersionOrThrow() {
-        return this.status.getCurrentVersionOrThrow();
-    }
-    getNonGarbageVersions() {
-        return this.status.getNonGarbageVersions();
+    statusObj() {
+        return this.status;
     }
     async removeCurrentVersion() {
         await this.status.removeCurrentVersion(this.verObjs);

package/build/core/storage/local/obj-status.d.ts

@@ -1,45 +1,35 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { LocalObjStatus, ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { VersionsInfo } from '../common/obj-info-file';
+import { LogError } from '../../../lib-client/logging/log-to-file';
 export interface ObjStatusInfo {
     objId: ObjId;
     isArchived?: boolean;
-    /**
-     * This field indicates current object version in cache.
-     */
-    currentVersion?: number;
-    /**
-     * This is a list of archived versions in the cache.
-     */
-    archivedVersions: number[];
-    /**
-     * This is a map from base version to diff-ed version(s), that use(s) base.
-     */
-    baseToDiff: {
-        [baseVersion: number]: number[];
-    };
-    /**
-     * This is a map from diff version to base version.
-     */
-    diffToBase: {
-        [diffVersion: number]: number;
-    };
+    versions: VersionsInfo;
 }
-export declare class ObjStatus {
+export declare class ObjStatus implements LocalObjStatus {
     private readonly objFolder;
     private readonly status;
+    private readonly logError;
     private readonly saveProc;
-    constructor(objFolder: string, status: ObjStatusInfo);
-    static readFrom(objFolder: string, objId: ObjId): Promise<ObjStatus>;
-    static makeNew(objFolder: string, objId: ObjId): Promise<ObjStatus>;
-    private saveFile;
+    constructor(objFolder: string, status: ObjStatusInfo, logError: LogError | undefined);
+    static readFrom(objFolder: string, objId: ObjId, logError: LogError | undefined): Promise<ObjStatus>;
+    static makeNew(objFolder: string, objId: ObjId, logError: LogError | undefined): Promise<ObjStatus>;
+    private triggerSaveProc;
     isArchived(): boolean;
     getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer: number | undefined;
-        nonGarbage: Set<number>;
-    };
+    getNonGarbageVersions(): NonGarbage;
     setNewCurrentVersion(newVersion: number, baseVer: number | undefined): Promise<void>;
     removeCurrentVersion(verObjs: ContainerWithDelete<number>): Promise<void>;
     removeArchivedVersion(version: number, verObjs: ContainerWithDelete<number>): Promise<void>;
+    archiveCurrentVersion(): Promise<void>;
+    listVersions(): {
+        current?: number;
+        archived?: number[];
+    };
+}
+export interface NonGarbage {
+    gcMaxVer?: number;
+    nonGarbage: Set<number>;
 }
 interface ContainerWithDelete<T> {
     delete(key: T): void;