core-3nweb-client-lib 0.26.1 → 0.27.3

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,39 @@ 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 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' });
-    }
+async function getAndCacheRootKeyDerivParamsFromServer(folder, getFromServer) {
+    const params = await getFromServer();
+    await saveRootKeyDerivParamsToDisk(folder, params);
     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);
-    }
+async function saveRootKeyDerivParamsToDisk(folder, params) {
+    await fs.writeFile((0, path_1.join)(folder, KD_PARAMS_FILE_NAME), JSON.stringify(params), { encoding: 'utf8' });
 }
-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) {
@@ -137,47 +119,45 @@ class StorageAndFS {
             }
         }
     }
-    static async newOrExisting(storage, key) {
+    static async makeNew(storage, key) {
+        var _a;
         const s = new StorageAndFS(storage);
-        try {
-            s.rootFS = await fs_1.XspFS.fromExistingRoot(s.storage, key);
-            return s;
-        }
-        catch (err) {
-            if (err.objNotFound) {
-                s.rootFS = await fs_1.XspFS.makeNewRoot(s.storage, key);
-                await initSysFolders(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;
     }
-    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 +167,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,34 +251,36 @@ 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;
         }
-        return async (getSigner) => {
-            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);
-            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(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);
+        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.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);
     }
@@ -316,7 +303,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 +329,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 +359,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 +416,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 +482,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 +494,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)('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
@@ -20,6 +20,7 @@ exports.GC = void 0;
 const fs = require("../../../lib-common/async-fs-node");
 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;
@@ -49,54 +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(noop));
-            }
-            if (rmProcs.length > 0) {
-                await Promise.all(rmProcs);
+            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;
 }
-function noop() { }
 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;
@@ -29,12 +30,8 @@ export declare class LocalObj {
     getObjSrc(version: number): Promise<ObjSource>;
     private objSegsGetterFromDisk;
     saveNewVersion(version: number, encSub: Subscribe): Promise<void>;
-    isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        nonGarbage: Set<number>;
-    };
+    localStatus(): LocalObjStatus;
+    statusObj(): ObjStatus;
     removeCurrentVersion(): Promise<void>;
     removeArchivedVersion(version: number): Promise<void>;
 }

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

@@ -28,7 +28,7 @@ class ObjFiles {
     constructor(folders, logError) {
         this.folders = folders;
         this.logError = logError;
-        this.objs = timed_cache_1.makeTimedCache(60 * 1000);
+        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) {
@@ -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) {
@@ -120,7 +120,7 @@ class LocalObj {
         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,4 +1,4 @@
-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 {
@@ -6,7 +6,7 @@ export interface ObjStatusInfo {
     isArchived?: boolean;
     versions: VersionsInfo;
 }
-export declare class ObjStatus {
+export declare class ObjStatus implements LocalObjStatus {
     private readonly objFolder;
     private readonly status;
     private readonly logError;
@@ -17,13 +17,19 @@ export declare class ObjStatus {
     private triggerSaveProc;
     isArchived(): boolean;
     getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        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;

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

@@ -19,15 +19,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjStatus = void 0;
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
-const json_saving_1 = require("../common/json-saving");
 const obj_info_file_1 = require("../common/obj-info-file");
+const json_saving_1 = require("../common/json-saving");
+const obj_info_file_2 = require("../common/obj-info-file");
+const assert_1 = require("../../../lib-common/assert");
 const STATUS_FILE_NAME = 'status';
 class ObjStatus {
     constructor(objFolder, status, logError) {
         this.objFolder = objFolder;
         this.status = status;
         this.logError = logError;
-        this.saveProc = new json_saving_1.JSONSavingProc(path_1.join(this.objFolder, STATUS_FILE_NAME), () => this.status);
+        this.saveProc = new json_saving_1.JSONSavingProc((0, path_1.join)(this.objFolder, STATUS_FILE_NAME), () => this.status);
         Object.freeze(this);
     }
     static async readFrom(objFolder, objId, logError) {
@@ -61,17 +63,17 @@ class ObjStatus {
     }
     getNonGarbageVersions() {
         return {
-            nonGarbage: obj_info_file_1.nonGarbageVersionsIn(this.status.versions),
+            nonGarbage: (0, obj_info_file_2.nonGarbageVersionsIn)(this.status.versions),
             gcMaxVer: this.status.versions.current
         };
     }
     async setNewCurrentVersion(newVersion, baseVer) {
-        obj_info_file_1.setCurrentVersionIn(this.status.versions, newVersion, baseVer);
+        (0, obj_info_file_2.setCurrentVersionIn)(this.status.versions, newVersion, baseVer);
         await this.triggerSaveProc();
     }
     async removeCurrentVersion(verObjs) {
         this.status.isArchived = true;
-        const current = obj_info_file_1.rmCurrentVersionIn(this.status.versions);
+        const current = (0, obj_info_file_2.rmCurrentVersionIn)(this.status.versions);
         if (typeof current === 'number') {
             verObjs.delete(current);
         }
@@ -79,23 +81,36 @@ class ObjStatus {
     }
     async removeArchivedVersion(version, verObjs) {
         verObjs.delete(version);
-        obj_info_file_1.rmArchVersionsIn(this.status.versions, version);
+        (0, obj_info_file_2.rmArchVersionFrom)(this.status.versions, version);
+        await this.triggerSaveProc();
+    }
+    async archiveCurrentVersion() {
+        const versions = this.status.versions;
+        (0, assert_1.assert)(!!versions.current);
+        (0, obj_info_file_1.addArchived)(versions, versions.current);
         await this.triggerSaveProc();
     }
+    listVersions() {
+        const archived = this.status.versions.archived;
+        return {
+            current: this.status.versions.current,
+            archived: (archived ? archived.slice() : [])
+        };
+    }
 }
 exports.ObjStatus = ObjStatus;
 Object.freeze(ObjStatus.prototype);
 Object.freeze(ObjStatus);
 async function readAndCheckStatus(objFolder, objId) {
-    const status = await obj_info_file_1.readJSONInfoFileIn(objFolder, STATUS_FILE_NAME);
+    const status = await (0, obj_info_file_2.readJSONInfoFileIn)(objFolder, STATUS_FILE_NAME);
     if (!status) {
-        throw exceptions_1.makeStorageException({
+        throw (0, exceptions_1.makeStorageException)({
             message: `Obj status file is not found in obj folder ${objFolder}`
         });
     }
     // XXX we may do some checks and sanitization here
     if (objId !== status.objId) {
-        throw exceptions_1.makeStorageException({ message: `Invalid objId in status file for obj ${objId}, in folder ${objFolder}.\nInvalid content:\n${JSON.stringify(status, null, 2)}` });
+        throw (0, exceptions_1.makeStorageException)({ message: `Invalid objId in status file for obj ${objId}, in folder ${objFolder}.\nInvalid content:\n${JSON.stringify(status, null, 2)}` });
     }
     return status;
 }