core-3nweb-client-lib 0.20.9 → 0.23.0

package/build/lib-client/3nstorage/xsp-fs/file-node.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020 3NSoft Inc.
+ Copyright (C) 2015 - 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,7 +13,8 @@
  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.FileNode = void 0;
 /**
@@ -25,96 +26,78 @@ const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const processes_1 = require("../../../lib-common/processes");
 const xsp_files_1 = require("xsp-files");
 const assert_1 = require("../../../lib-common/assert");
-const file_source_1 = require("../../files/file-source");
-const file_sink_1 = require("../../files/file-sink");
-const file_attrs_1 = require("../../files/file-attrs");
-const file_layout_1 = require("../../files/file-layout");
+const attrs_1 = require("./attrs");
 const file_1 = require("../../../lib-common/exceptions/file");
-class FileCrypto extends node_in_fs_1.NodeCrypto {
+const node_persistence_1 = require("./node-persistence");
+async function fileAttrsFrom(payload) {
+    const attrs = payload.getAttrs();
+    const xattrs = await payload.getXAttrs();
+    return { attrs: attrs_1.CommonAttrs.fromAttrs(attrs), size: attrs.size, xattrs };
+}
+class FilePersistance extends node_persistence_1.NodePersistance {
     constructor(zNonce, key, cryptor) {
         super(zNonce, key, cryptor);
         Object.seal(this);
     }
-    async getAttrsAndByteSrc(src) {
-        const { byteSrc, attrsBytes } = await super.getAttrsAndByteSrc(src);
-        if (attrsBytes) {
-            return {
-                byteSrc,
-                attrs: file_attrs_1.AttrsHolder.fromBytesReadonly(attrsBytes),
-                attrsByteSize: attrsBytes.length
-            };
-        }
-        else {
-            return { byteSrc };
-        }
-    }
-    async decryptedBytesSource(src) {
-        const { byteSrc, attrs } = await this.getAttrsAndByteSrc(src);
-        const fileSrc = await file_source_1.FileBytes.from(byteSrc, attrs);
-        return { attrs, fileSrc };
+    async getAttrs(objSrc) {
+        const payload = await super.readonlyPayload(objSrc);
+        return await fileAttrsFrom(payload);
     }
-    async saveBytes(bytes, version, attrs) {
-        attrs.setContinuousFileSize(Array.isArray(bytes) ?
-            buffer_utils_1.byteLengthIn(bytes) : bytes.length);
-        return super.saveBytes(bytes, version, attrs);
+    async getFileSource(objSrc, getAttrs = false) {
+        const payload = await this.readonlyPayload(objSrc);
+        const src = payload.makeFileByteSource();
+        return (getAttrs ?
+            { src, fileAttrs: await fileAttrsFrom(payload) } :
+            { src });
     }
-    async encryptingByteSink(version, attrs, base) {
-        attrs.mtime = Date.now();
-        let writer;
-        let baseAttrsSize;
-        let layout;
-        let initLayoutOfs;
-        if (base) {
-            writer = await this.segWriterWithBase(version, base);
-            const { byteSrc: baseSrc, attrs: baseAttrs, attrsByteSize } = await this.getAttrsAndByteSrc(base);
-            baseAttrsSize = (baseAttrs ? attrsByteSize : 0);
-            if (baseAttrs) {
-                initLayoutOfs = baseAttrs.getFileSize();
-                if (typeof initLayoutOfs === 'number') {
-                    layout = file_layout_1.RWFileLayout.orderedWithBaseSize(initLayoutOfs);
-                }
-                else {
-                    initLayoutOfs = baseAttrs.getFileLayoutOfs();
-                    if (typeof initLayoutOfs !== 'number') {
-                        throw new Error(`File attributes have neither file size, nor pointer to layout`);
-                    }
-                    layout = await file_layout_1.RWFileLayout.readFromSrc(baseSrc, initLayoutOfs);
-                }
-            }
-            else {
-                const { size } = await baseSrc.getSize();
-                initLayoutOfs = size;
-                layout = file_layout_1.RWFileLayout.orderedWithBaseSize(size);
+    async readBytes(objSrc, start, end, getAttrs = false) {
+        if ((typeof start === 'number') && (start < 0)) {
+            throw new Error(`Parameter start has bad value: ${start}`);
+        }
+        if ((typeof end === 'number') && (end < 0)) {
+            throw new Error(`Parameter end has bad value: ${end}`);
+        }
+        const payload = await this.readonlyPayload(objSrc);
+        const size = payload.getAttrs().size;
+        if (start === undefined) {
+            start = 0;
+            end = size;
+        }
+        else if (start >= size) {
+            return (getAttrs ? { fileAttrs: await fileAttrsFrom(payload) } : {});
+        }
+        if (typeof end === 'number') {
+            end = Math.min(size, end);
+            if (end <= start) {
+                return (getAttrs ?
+                    { fileAttrs: await fileAttrsFrom(payload) } : {});
             }
         }
         else {
-            writer = await this.segWriter(version);
-            baseAttrsSize = undefined;
-            initLayoutOfs = undefined;
-            layout = file_layout_1.RWFileLayout.orderedWithBaseSize(0);
+            end = size;
         }
-        const { sink, sub: originalSub } = xsp_files_1.makeEncryptingByteSinkWithAttrs(writer, baseAttrsSize);
-        const deferredFileSink = processes_1.defer();
-        return {
-            sub: obs => {
-                const unsub = originalSub(obs);
-                file_sink_1.FileSink.from(sink, attrs, layout).then(sink => deferredFileSink.resolve(sink), err => deferredFileSink.reject(err));
-                return unsub;
-            },
-            sinkDef: deferredFileSink.promise,
-            cancelSinkDef: deferredFileSink.reject
-        };
+        const bytes = await payload.readSomeContentBytes(start, end);
+        return (getAttrs ?
+            { bytes, fileAttrs: await fileAttrsFrom(payload) } :
+            { bytes });
+    }
+    async saveBytes(bytes, version, attrs, xattrs) {
+        return super.writeWhole(bytes, version, attrs, xattrs);
+    }
+    async getFileSink(version, attrs, xattrs, base) {
+        return await super.writableSink(version, attrs, xattrs, base);
     }
 }
-Object.freeze(FileCrypto.prototype);
-Object.freeze(FileCrypto);
+Object.freeze(FilePersistance.prototype);
+Object.freeze(FilePersistance);
 class FileNode extends node_in_fs_1.NodeInFS {
     constructor(storage, fileName, objId, version, parentId, key) {
         super(storage, 'file', fileName, objId, version, parentId);
+        this.fileSize = 0;
         if (!fileName || !objId) {
             throw new Error("Bad file parameter(s) given");
         }
-        this.crypto = new FileCrypto(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
+        this.crypto = new FilePersistance(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
         Object.seal(this);
     }
     static async makeForNew(storage, parentId, name, key) {
@@ -123,7 +106,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
         }
         const objId = await storage.generateNewObjId();
         const file = new FileNode(storage, name, objId, 0, parentId, key);
-        file.attrs = file_attrs_1.AttrsHolder.makeReadonlyForFile(Date.now());
+        file.attrs = attrs_1.CommonAttrs.makeForTimeNow();
         return file;
     }
     static async makeForExisting(storage, parentId, fileName, objId, key) {
@@ -142,47 +125,76 @@ class FileNode extends node_in_fs_1.NodeInFS {
     static async initWithAttrs(storage, parentId, fileName, objId, key) {
         const src = await storage.getObj(objId);
         const file = new FileNode(storage, fileName, objId, src.version, parentId, key);
-        const { attrs } = await file.crypto.getAttrsAndByteSrc(src);
-        file.attrs = (attrs ?
-            attrs : file_attrs_1.AttrsHolder.makeReadonlyForFile(Date.now()));
+        const fileAttrs = await file.crypto.getAttrs(src);
+        file.setUpdatedState(src.version, fileAttrs);
         return file;
     }
+    setUpdatedState(version, fileAttrs) {
+        this.fileSize = fileAttrs.size;
+        super.setUpdatedParams(version, fileAttrs.attrs, fileAttrs.xattrs);
+    }
+    get size() {
+        return this.fileSize;
+    }
     async readSrc() {
         const objSrc = await this.storage.getObj(this.objId);
-        const { fileSrc: src } = await this.crypto.decryptedBytesSource(objSrc);
-        let version;
         if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
-            version = objSrc.version;
+            const version = objSrc.version;
             if (this.version < version) {
-                this.setCurrentVersion(version);
+                const { src, fileAttrs } = await this.crypto.getFileSource(objSrc, true);
+                this.setUpdatedState(version, fileAttrs);
+                return { src, version };
+            }
+            else {
+                const { src } = await this.crypto.getFileSource(objSrc);
+                return { src, version };
             }
         }
         else {
+            const { src } = await this.crypto.getFileSource(objSrc);
             // unversioned storage passes undefined version
-            version = undefined;
+            return { src, version: undefined };
         }
-        return { src, version };
     }
-    async writeSink(truncate, currentVersion) {
+    async readBytes(start, end) {
+        const objSrc = await this.storage.getObj(this.objId);
+        if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
+            const version = objSrc.version;
+            if (this.version < version) {
+                const { bytes, fileAttrs } = await this.crypto.readBytes(objSrc, start, end, true);
+                this.setUpdatedState(version, fileAttrs);
+                return { bytes, version };
+            }
+            else {
+                const { bytes } = await this.crypto.readBytes(objSrc, start, end);
+                return { bytes, version };
+            }
+        }
+        else {
+            const { bytes } = await this.crypto.readBytes(objSrc, start, end);
+            // unversioned storage passes undefined version
+            return { bytes, version: undefined };
+        }
+    }
+    async writeSink(truncate, currentVersion, changes) {
         const deferredSink = processes_1.defer();
-        let newVersion = 0; // need to set any value to satisfy compiler
+        const newSize = processes_1.defer();
+        let version = 0; // need to set any value to satisfy compiler
         const completion = this.doChange(false, async () => {
-            const step1 = await this.startMakingSinkInsideChange(truncate, currentVersion).catch(err => {
-                deferredSink.reject(err);
-                throw err;
-            });
-            newVersion = step1.newVersion;
-            deferredSink.resolve({ sinkPromise: step1.sinkDef });
-            await this.savingObjInsideChange(step1.attrs, step1.newVersion, step1.sub).catch(err => {
-                step1.cancelSinkDef(err);
-                throw err;
-            });
+            const { attrs, xattrs, newVersion, sinkPromise, sub } = await this.startMakingSinkInsideChange(truncate, currentVersion, changes);
+            version = newVersion;
+            deferredSink.resolve(sinkPromise);
+            await this.savingObjInsideChange(attrs, newSize.promise, xattrs, newVersion, sub);
         });
-        // in case overall completion is never waited, if early error comes
-        completion.catch(noop);
-        // explicitly await two steps to get all possible errors
-        const sDef = await deferredSink.promise; // after await newVersion is set
-        const sink = await sDef.sinkPromise;
+        let sink = undefined;
+        // race allows to either get sink or threw possible errors from completion
+        await Promise.race([
+            deferredSink.promise.then(async (sinkPromise) => {
+                sink = await sinkPromise;
+            }),
+            completion
+        ]);
+        assert_1.assert(!!sink);
         // sink's done should await completion of obj saving, and
         // error in obj saving should cancel sink
         const originalDone = sink.done;
@@ -190,48 +202,48 @@ class FileNode extends node_in_fs_1.NodeInFS {
         assert_1.assert(!Object.isFrozen(sink), `Can't mutate frozen sink`);
         sink.done = async (err) => {
             if (err) {
+                newSize.resolve(0);
                 await originalDone(err);
+                await completion.catch(noop);
             }
             else {
+                const size = await sink.getSize();
+                newSize.resolve(size);
                 await originalDone();
                 await completion;
             }
         };
-        return {
-            sink,
-            version: newVersion
-        };
+        return { sink, version };
     }
-    async startMakingSinkInsideChange(truncate, currentVersion) {
+    async startMakingSinkInsideChange(truncate, currentVersion, changes) {
         if ((typeof currentVersion === 'number')
             && (this.version !== currentVersion)) {
             throw file_1.makeVersionMismatchExc(this.name);
         }
-        const newVersion = this.version + 1;
-        const attrs = this.attrs.modifiableCopy();
+        const { attrs, xattrs, newVersion } = super.getParamsForUpdate(changes);
         const base = ((truncate || (this.version === 0)) ?
             undefined :
             await this.storage.getObj(this.objId));
-        const { sinkDef, sub, cancelSinkDef } = await this.crypto.encryptingByteSink(newVersion, attrs, base);
-        return { attrs, newVersion, sinkDef, sub, cancelSinkDef };
+        const { sinkPromise, sub } = await this.crypto.getFileSink(newVersion, attrs, xattrs, base);
+        return { attrs, xattrs, newVersion, sinkPromise, sub };
     }
-    async savingObjInsideChange(attrs, newVersion, encSub) {
+    async savingObjInsideChange(attrs, newSize, xattrs, newVersion, encSub) {
         await this.storage.saveObj(this.objId, newVersion, encSub);
-        this.setCurrentVersion(newVersion);
-        attrs.setReadonly();
-        this.attrs = attrs;
+        const size = await newSize;
+        this.setUpdatedState(newVersion, { attrs, size, xattrs });
         this.broadcastEvent({
             type: 'file-change',
             path: this.name,
             newVersion
         });
     }
-    save(bytes) {
+    save(bytes, changes) {
         return this.doChange(false, async () => {
-            const newVersion = this.version + 1;
-            const attrs = this.attrs.modifiableCopy();
-            const encSub = await this.crypto.saveBytes(bytes, newVersion, attrs);
-            await this.savingObjInsideChange(attrs, newVersion, encSub);
+            const { attrs, xattrs, newVersion } = super.getParamsForUpdate(changes);
+            const encSub = await this.crypto.saveBytes(bytes, newVersion, attrs, xattrs);
+            const newSize = Promise.resolve(Array.isArray(bytes) ?
+                buffer_utils_1.byteLengthIn(bytes) : bytes.length);
+            await this.savingObjInsideChange(attrs, newSize, xattrs, newVersion, encSub);
             return this.version;
         });
     }

package/build/lib-client/3nstorage/xsp-fs/file.d.ts

@@ -10,7 +10,6 @@ declare type Observer<T> = web3n.Observer<T>;
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
-export declare function readBytesFrom(src: FileByteSource, start: number | undefined, end: number | undefined): Promise<Uint8Array | undefined>;
 export declare class FileObject implements WritableFile, Linkable {
     name: string;
     isNew: boolean;

package/build/lib-client/3nstorage/xsp-fs/file.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,9 +13,10 @@
  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.FileObject = exports.readBytesFrom = void 0;
+exports.FileObject = void 0;
 /**
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
@@ -25,46 +26,6 @@ const files_1 = require("../../files");
 const file_node_1 = require("./file-node");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const pipe_1 = require("../../../lib-common/byte-streaming/pipe");
-async function readBytesFrom(src, start, end) {
-    if ((typeof start === 'number') && (start < 0)) {
-        throw new Error(`Parameter start has bad value: ${start}`);
-    }
-    if ((typeof end === 'number') && (end < 0)) {
-        throw new Error(`Parameter end has bad value: ${end}`);
-    }
-    const size = await src.getSize();
-    if (typeof size !== 'number') {
-        throw new Error('File size is not known.');
-    }
-    if (size === 0) {
-        return;
-    }
-    if (typeof start === 'number') {
-        if (start >= size) {
-            return;
-        }
-        if (typeof end === 'number') {
-            end = Math.min(size, end);
-            if (end <= start) {
-                return;
-            }
-        }
-        else {
-            end = size;
-        }
-        if (!src.seek) {
-            throw new Error('Byte source is not seekable.');
-        }
-        await src.seek(start);
-        const bytes = await src.read(end - start);
-        return bytes;
-    }
-    else {
-        const bytes = await src.read(undefined);
-        return bytes;
-    }
-}
-exports.readBytesFrom = readBytesFrom;
 class FileObject {
     constructor(name, isNew, node, makeOrGetNode, writable) {
         this.name = name;
@@ -99,11 +60,14 @@ class FileObject {
         if (!this.v.node) {
             throw file_1.makeFileException(file_1.Code.notFound, this.name);
         }
-        const { src } = await this.v.node.readSrc();
+        const attrs = this.v.node.getAttrs();
         const stat = {
             writable: this.writable,
-            size: await src.getSize(),
-            version: this.v.node.version
+            size: this.v.node.size,
+            version: this.v.node.version,
+            isFile: true,
+            ctime: new Date(attrs.ctime),
+            mtime: new Date(attrs.mtime),
         };
         return stat;
     }
@@ -226,9 +190,10 @@ class V {
         return this.writeTxt(JSON.stringify(json));
     }
     async readBytes(start, end) {
-        const { src, version } = await this.getByteSource();
-        const bytes = await readBytesFrom(src, start, end);
-        return { bytes, version };
+        if (!this.node) {
+            throw file_1.makeFileException(file_1.Code.notFound, this.name);
+        }
+        return await this.node.readBytes(start, end);
     }
     async readTxt() {
         const { bytes, version } = await this.readBytes();

package/build/lib-client/3nstorage/xsp-fs/folder-node-serialization.d.ts

@@ -1,3 +1,3 @@
 import { FolderInfo } from './folder-node';
+export declare function parseFolderInfo(bytes: Uint8Array | undefined): FolderInfo;
 export declare function serializeFolderInfo(folderInfo: FolderInfo): Uint8Array[];
-export declare function deserializeFolderInfo(bytes: Uint8Array): FolderInfo;