core-3nweb-client-lib 0.21.0 → 0.24.0

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

@@ -2,25 +2,30 @@
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
  */
-import { NodeInFS, NodeCrypto } from './node-in-fs';
+import { NodeInFS } from './node-in-fs';
 import { LinkParameters } from '../../files';
 import { Storage, AsyncSBoxCryptor } from './common';
-import { ObjSource } from 'xsp-files';
-import { LinkAttrs, AttrsHolder } from '../../files/file-attrs';
-declare class LinkCrypto extends NodeCrypto {
+import { ObjSource, Subscribe } from 'xsp-files';
+import { CommonAttrs, XAttrs } from './attrs';
+import { NodePersistance } from './node-persistence';
+declare class LinkPersistance extends NodePersistance {
     constructor(zNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
-    readLinkParams(src: ObjSource): Promise<{
+    read(src: ObjSource): Promise<{
         params: LinkParameters<any>;
-        attrs?: AttrsHolder<LinkAttrs>;
+        attrs: CommonAttrs;
+        xattrs?: XAttrs;
     }>;
+    write(params: LinkParameters<any>, version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined): Promise<Subscribe>;
 }
 declare type SymLink = web3n.files.SymLink;
-export declare class LinkNode extends NodeInFS<LinkCrypto, LinkAttrs> {
+declare type XAttrsChanges = web3n.files.XAttrsChanges;
+export declare class LinkNode extends NodeInFS<LinkPersistance> {
     private linkParams;
     constructor(storage: Storage, name: string, objId: string, version: number, parentId: string | undefined, key: Uint8Array);
     static makeForNew(storage: Storage, parentId: string, name: string, key: Uint8Array): Promise<LinkNode>;
     static makeForExisting(storage: Storage, parentId: string, name: string, objId: string, key: Uint8Array): Promise<LinkNode>;
-    setLinkParams(params: LinkParameters<any>): Promise<void>;
+    private setUpdatedState;
+    save(params: LinkParameters<any>, changes?: XAttrsChanges): Promise<void>;
     private getLinkParams;
     read(): Promise<SymLink>;
     private makeLinkToSharedStorage;

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2018, 2020 3NSoft Inc.
+ Copyright (C) 2016 - 2018, 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.LinkNode = void 0;
 /**
@@ -22,38 +23,31 @@ exports.LinkNode = void 0;
  */
 const node_in_fs_1 = require("./node-in-fs");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
-const error_1 = require("../../../lib-common/exceptions/error");
 const device_fs_1 = require("../../local-files/device-fs");
 const file_1 = require("./file");
 const fs_1 = require("./fs");
 const xsp_files_1 = require("xsp-files");
-const file_attrs_1 = require("../../files/file-attrs");
-class LinkCrypto extends node_in_fs_1.NodeCrypto {
+const attrs_1 = require("./attrs");
+const node_persistence_1 = require("./node-persistence");
+class LinkPersistance extends node_persistence_1.NodePersistance {
     constructor(zNonce, key, cryptor) {
         super(zNonce, key, cryptor);
         Object.seal(this);
     }
-    async readLinkParams(src) {
-        try {
-            const { content, attrs } = await this.readBytes(src);
-            const params = JSON.parse(buffer_utils_1.utf8.open(content));
-            if (attrs) {
-                return {
-                    params,
-                    attrs: file_attrs_1.AttrsHolder.fromBytesReadonly(attrs)
-                };
-            }
-            else {
-                return { params };
-            }
-        }
-        catch (exc) {
-            throw error_1.errWithCause(exc, `Cannot open link object`);
+    async read(src) {
+        const { content, attrs, xattrs } = await super.readAll(src);
+        if (!content) {
+            throw `Cannot open link object`;
         }
+        const params = formatV1.parse(content);
+        return { params, xattrs, attrs: attrs_1.CommonAttrs.fromAttrs(attrs) };
+    }
+    async write(params, version, attrs, xattrs) {
+        return super.writeWhole(formatV1.pack(params), version, attrs, xattrs);
     }
 }
-Object.freeze(LinkCrypto.prototype);
-Object.freeze(LinkCrypto);
+Object.freeze(LinkPersistance.prototype);
+Object.freeze(LinkPersistance);
 function makeFileSymLink(storage, params) {
     const sl = {
         isFile: true,
@@ -88,38 +82,38 @@ class LinkNode extends node_in_fs_1.NodeInFS {
         if (!name || !objId || !parentId) {
             throw new Error("Bad link parameter(s) given");
         }
-        this.crypto = new LinkCrypto(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
-        this.attrs = file_attrs_1.AttrsHolder.makeReadonlyForLink(Date.now());
+        this.crypto = new LinkPersistance(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
         Object.seal(this);
     }
     static async makeForNew(storage, parentId, name, key) {
         const objId = await storage.generateNewObjId();
         const link = new LinkNode(storage, name, objId, 0, parentId, key);
-        link.attrs = file_attrs_1.AttrsHolder.makeReadonlyForLink(Date.now());
+        link.attrs = attrs_1.CommonAttrs.makeForTimeNow();
         return link;
     }
     static async makeForExisting(storage, parentId, name, objId, key) {
         const src = await storage.getObj(objId);
         const link = new LinkNode(storage, name, objId, src.version, parentId, key);
-        const { params, attrs } = await link.crypto.readLinkParams(src);
-        link.linkParams = params;
-        link.attrs = (attrs ? attrs : file_attrs_1.AttrsHolder.makeReadonlyForLink(0));
+        const { params, attrs, xattrs } = await link.crypto.read(src);
+        link.setUpdatedState(params, src.version, attrs, xattrs);
         return link;
     }
-    async setLinkParams(params) {
+    setUpdatedState(params, version, attrs, xattrs) {
+        this.linkParams = params;
+        super.setUpdatedParams(version, attrs, xattrs);
+    }
+    async save(params, changes) {
         if (this.linkParams) {
             throw new Error('Cannot set link parameters second time');
         }
         return this.doChange(false, async () => {
-            const newVersion = this.version + 1;
-            this.linkParams = params;
-            const bytes = buffer_utils_1.utf8.pack(JSON.stringify(params));
-            const attrs = this.attrs.modifiableCopy();
-            const sinkSub = await this.crypto.saveBytes(bytes, newVersion, attrs);
+            // prepare data for recording
+            const { attrs, xattrs, newVersion } = this.getParamsForUpdate(changes);
+            // save/record
+            const sinkSub = await this.crypto.write(params, newVersion, attrs, xattrs);
             await this.storage.saveObj(this.objId, newVersion, sinkSub);
-            this.setCurrentVersion(newVersion);
-            attrs.setReadonly();
-            this.attrs = attrs;
+            // set updated data in the node
+            this.setUpdatedState(params, newVersion, attrs, xattrs);
         });
     }
     async getLinkParams() {
@@ -205,4 +199,18 @@ class LinkNode extends node_in_fs_1.NodeInFS {
 exports.LinkNode = LinkNode;
 Object.freeze(LinkNode.prototype);
 Object.freeze(LinkNode);
+var formatV1;
+(function (formatV1) {
+    // XXX make proper type version check
+    function pack(params) {
+        return buffer_utils_1.utf8.pack(JSON.stringify(params));
+    }
+    formatV1.pack = pack;
+    function parse(bytes) {
+        const params = JSON.parse(buffer_utils_1.utf8.open(bytes));
+        return params;
+    }
+    formatV1.parse = parse;
+})(formatV1 || (formatV1 = {}));
+Object.freeze(formatV1);
 Object.freeze(exports);

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

@@ -1,53 +1,35 @@
-/**
- * Everything in this module is assumed to be inside of a file system
- * reliance set.
- */
-import { AsyncSBoxCryptor, SegmentsWriter, SegmentsReader, Subscribe, ObjSource, ByteSource } from 'xsp-files';
 import { Node, NodeType, Storage, RemoteEvent } from './common';
 import { Observable } from 'rxjs';
-import { AttrsHolder, EntityAttrs } from '../../files/file-attrs';
-export declare abstract class NodeCrypto {
-    private zerothHeaderNonce;
-    private key;
-    private cryptor;
-    protected constructor(zerothHeaderNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
-    wipe(): void;
-    compareKey(keyB64: string): boolean;
-    fileKeyInBase64(): string;
-    protected segWriter(version: number): Promise<SegmentsWriter>;
-    protected segWriterWithBase(newVersion: number, base: ObjSource): Promise<SegmentsWriter>;
-    protected segReader(src: ObjSource): Promise<SegmentsReader>;
-    saveBytes(bytes: Uint8Array | Uint8Array[], version: number, attrs: AttrsHolder<any>): Promise<Subscribe>;
-    saveAttrs<T extends EntityAttrs>(attrs: AttrsHolder<T>, version: number, base: ObjSource | undefined): Promise<Subscribe>;
-    getAttrsAndByteSrc(src: ObjSource): Promise<{
-        attrsBytes?: Uint8Array;
-        byteSrc: ByteSource;
-    }>;
-    readBytes(src: ObjSource): Promise<{
-        content: Uint8Array;
-        attrs?: Uint8Array;
-    }>;
-    reencryptHeader: (initHeader: Uint8Array, newVersion: number) => Promise<Uint8Array>;
-}
+import { CommonAttrs, XAttrs } from './attrs';
+import { NodePersistance } from './node-persistence';
 export declare type FSEvent = web3n.files.FolderEvent | web3n.files.FileEvent;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
-export declare abstract class NodeInFS<TCrypto extends NodeCrypto, TAttrs extends EntityAttrs> implements Node {
-    protected storage: Storage;
-    type: NodeType;
+export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
+    protected readonly storage: Storage;
+    readonly type: NodeType;
     name: string;
-    objId: string;
+    readonly objId: string;
     private currentVersion;
     parentId: string | undefined;
-    protected crypto: TCrypto;
-    protected attrs: AttrsHolder<TAttrs>;
+    protected crypto: P;
+    protected attrs: CommonAttrs;
+    protected xattrs: XAttrs | undefined;
     private writeProc;
     get version(): number;
     protected setCurrentVersion(newVersion: number): void;
     private remoteEvents;
     protected constructor(storage: Storage, type: NodeType, name: string, objId: string, currentVersion: number, parentId: string | undefined);
+    private updatedXAttrs;
+    protected setUpdatedParams(version: number, attrs: CommonAttrs | undefined, xattrs: XAttrs | undefined): void;
+    protected getParamsForUpdate(changes: XAttrsChanges | undefined): {
+        newVersion: number;
+        attrs: CommonAttrs;
+        xattrs?: XAttrs;
+    };
     updateXAttrs(changes: XAttrsChanges): Promise<number>;
     getXAttr(xaName: string): any;
     listXAttrs(): string[];
+    getAttrs(): CommonAttrs;
     processRemoteEvent(event: RemoteEvent): Promise<void>;
     private bufferRemoteEvent;
     private getBufferedEvent;

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.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,130 +13,20 @@
  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.NodeInFS = exports.NodeCrypto = void 0;
+exports.NodeInFS = void 0;
 /**
  * Everything in this module is assumed to be inside of a file system
  * reliance set.
  */
-const xsp_files_1 = require("xsp-files");
-const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const processes_1 = require("../../../lib-common/processes");
-const random = require("../../../lib-common/random-node");
 const file_1 = require("../../../lib-common/exceptions/file");
 const error_1 = require("../../../lib-common/exceptions/error");
 const rxjs_1 = require("rxjs");
-const sink_utils_1 = require("../../../lib-common/obj-streaming/sink-utils");
 const operators_1 = require("rxjs/operators");
-const SEG_SIZE = 16; // in 256-byte blocks = 4K in bytes
-const EMPTY_BYTE_ARR = new Uint8Array(0);
-class NodeCrypto {
-    constructor(zerothHeaderNonce, key, cryptor) {
-        this.zerothHeaderNonce = zerothHeaderNonce;
-        this.key = key;
-        this.cryptor = cryptor;
-        this.reencryptHeader = async (initHeader, newVersion) => {
-            if (!this.key) {
-                throw new Error("Cannot use wiped object.");
-            }
-            const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
-            const n = xsp_files_1.calculateNonce(this.zerothHeaderNonce, newVersion);
-            return this.cryptor.formatWN.pack(headerContent, n, this.key);
-        };
-    }
-    wipe() {
-        if (this.key) {
-            this.key.fill(0);
-            this.key = undefined;
-            this.zerothHeaderNonce.fill(0);
-            this.zerothHeaderNonce = undefined;
-        }
-    }
-    compareKey(keyB64) {
-        const k = buffer_utils_1.base64.open(keyB64);
-        return xsp_files_1.compareVectors(k, this.key);
-    }
-    fileKeyInBase64() {
-        if (!this.key) {
-            throw new Error("Cannot use wiped object.");
-        }
-        return buffer_utils_1.base64.pack(this.key);
-    }
-    segWriter(version) {
-        if (!this.key) {
-            throw new Error("Cannot use wiped object.");
-        }
-        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, formatWithSections: true }, random.bytes, this.cryptor);
-    }
-    async segWriterWithBase(newVersion, base) {
-        if (!this.key) {
-            throw new Error("Cannot use wiped object.");
-        }
-        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, formatWithSections: true }, random.bytes, this.cryptor);
-    }
-    async segReader(src) {
-        if (!this.key) {
-            throw new Error("Cannot use wiped object.");
-        }
-        const version = src.version;
-        const header = await src.readHeader();
-        return xsp_files_1.makeSegmentsReader(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
-    }
-    async saveBytes(bytes, version, attrs) {
-        attrs.mtime = Date.now();
-        const segWriter = await this.segWriter(version);
-        const sub = sink_utils_1.encryptBytesToSinkProc(bytes, attrs.toBytes(), segWriter);
-        return sub;
-    }
-    async saveAttrs(attrs, version, base) {
-        if (base) {
-            const writer = await this.segWriterWithBase(version, base);
-            const { attrsBytes } = await this.getAttrsAndByteSrc(base);
-            const baseAttrsSize = (attrsBytes ? attrsBytes.length : 0);
-            return sink_utils_1.encryptAttrsToSinkProc(attrs.toBytes(), writer, baseAttrsSize);
-        }
-        else {
-            const writer = await this.segWriter(version);
-            return sink_utils_1.encryptAttrsToSinkProc(attrs.toBytes(), writer, undefined);
-        }
-    }
-    async getAttrsAndByteSrc(src) {
-        const segReader = await this.segReader(src);
-        if (segReader.formatVersion === 2) {
-            const byteSrc = await xsp_files_1.makeDecryptedByteSourceWithAttrs(src.segSrc, segReader);
-            const attrsBytes = await byteSrc.readAttrs();
-            return { byteSrc, attrsBytes };
-        }
-        else if (segReader.formatVersion === 1) {
-            const byteSrc = xsp_files_1.makeDecryptedByteSource(src.segSrc, segReader);
-            return { byteSrc };
-        }
-        else {
-            throw new Error(`XSP segments format ${segReader.formatVersion} is unknown`);
-        }
-    }
-    async readBytes(src) {
-        const segReader = await this.segReader(src);
-        if (segReader.formatVersion === 2) {
-            const decSrc = await xsp_files_1.makeDecryptedByteSourceWithAttrs(src.segSrc, segReader);
-            const attrs = await decSrc.readAttrs();
-            const bytes = await decSrc.read(undefined);
-            return { attrs, content: (bytes ? bytes : EMPTY_BYTE_ARR) };
-        }
-        else if (segReader.formatVersion === 1) {
-            const decSrc = xsp_files_1.makeDecryptedByteSource(src.segSrc, segReader);
-            const bytes = await decSrc.read(undefined);
-            return { content: (bytes ? bytes : EMPTY_BYTE_ARR) };
-        }
-        else {
-            throw new Error(`XSP segments format ${segReader.formatVersion} is unknown`);
-        }
-    }
-}
-exports.NodeCrypto = NodeCrypto;
-Object.freeze(NodeCrypto.prototype);
-Object.freeze(NodeCrypto);
+const attrs_1 = require("./attrs");
 class NodeInFS {
     constructor(storage, type, name, objId, currentVersion, parentId) {
         this.storage = storage;
@@ -147,6 +37,7 @@ class NodeInFS {
         this.parentId = parentId;
         this.crypto = undefined;
         this.attrs = undefined;
+        this.xattrs = undefined;
         this.writeProc = undefined;
         this.remoteEvents = undefined;
         /**
@@ -164,30 +55,46 @@ class NodeInFS {
         }
         this.currentVersion = newVersion;
     }
+    updatedXAttrs(changes) {
+        return (this.xattrs ?
+            (changes ? this.xattrs.makeUpdated(changes) : this.xattrs) :
+            (changes ? attrs_1.XAttrs.makeEmpty().makeUpdated(changes) : undefined));
+    }
+    setUpdatedParams(version, attrs, xattrs) {
+        if (attrs) {
+            this.attrs = attrs;
+        }
+        this.xattrs = xattrs;
+        this.setCurrentVersion(version);
+    }
+    getParamsForUpdate(changes) {
+        return {
+            newVersion: this.version + 1,
+            attrs: this.attrs.copy(),
+            xattrs: this.updatedXAttrs(changes)
+        };
+    }
     async updateXAttrs(changes) {
         if (Object.keys(changes).length === 0) {
             return this.version;
         }
         return this.doChange(true, async () => {
-            const newVersion = this.version + 1;
-            const attrs = this.attrs.modifiableCopy();
-            attrs.updateXAttrs(changes);
-            const base = ((this.version === 0) ?
-                undefined :
-                await this.storage.getObj(this.objId));
-            const sub = await this.crypto.saveAttrs(attrs, newVersion, base);
+            const { xattrs, newVersion } = this.getParamsForUpdate(changes);
+            const base = await this.storage.getObj(this.objId);
+            const sub = await this.crypto.writeXAttrs(xattrs, newVersion, base);
             await this.storage.saveObj(this.objId, newVersion, sub);
-            this.setCurrentVersion(newVersion);
-            attrs.setReadonly();
-            this.attrs = attrs;
+            this.setUpdatedParams(newVersion, undefined, xattrs);
             return this.version;
         });
     }
     getXAttr(xaName) {
-        return this.attrs.getXAttr(xaName);
+        return (this.xattrs ? this.xattrs.get(xaName) : undefined);
     }
     listXAttrs() {
-        return this.attrs.listXAttrs();
+        return (this.xattrs ? this.xattrs.list() : []);
+    }
+    getAttrs() {
+        return this.attrs;
     }
     processRemoteEvent(event) {
         this.bufferRemoteEvent(event);

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

@@ -0,0 +1,57 @@
+/**
+ * Everything in this module is assumed to be inside of a file system
+ * reliance set.
+ */
+import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
+import { CommonAttrs, XAttrs } from './attrs';
+/**
+ * This does reading and writing, keeping keys. This and extending objects are
+ * used in file system nodes as thematic place with persistence functionality.
+ */
+export declare abstract class NodePersistance {
+    private zerothHeaderNonce;
+    private key;
+    private cryptor;
+    protected constructor(zerothHeaderNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
+    wipe(): void;
+    compareKey(keyB64: string): boolean;
+    fileKeyInBase64(): string;
+    private segWriter;
+    private segWriterWithBase;
+    private decryptedByteSrc;
+    readonlyPayload(src: ObjSource): Promise<ReadonlyPayload>;
+    protected readAll(src: ObjSource): Promise<{
+        content: Uint8Array | undefined;
+        attrs: Attrs;
+        xattrs?: XAttrs;
+    }>;
+    private writablePayload;
+    protected writeWhole(content: Uint8Array | Uint8Array[], newVersion: number, attrs?: CommonAttrs, xattrs?: XAttrs): Promise<Subscribe>;
+    writeXAttrs(xattrs: XAttrs, newVersion: number, base: ObjSource): Promise<Subscribe>;
+    protected writableSink(newVersion: number, attrs?: CommonAttrs, xattrs?: XAttrs, base?: ObjSource): Promise<{
+        sinkPromise: Promise<FileByteSink>;
+        sub: Subscribe;
+    }>;
+    reencryptHeader: (initHeader: Uint8Array, newVersion: number) => Promise<Uint8Array>;
+}
+declare type FileByteSource = web3n.files.FileByteSource;
+declare type FileByteSink = web3n.files.FileByteSink;
+export interface ReadonlyPayload {
+    getAttrs(): Attrs;
+    getXAttrs(): Promise<XAttrs>;
+    readAllContent(): Promise<Uint8Array | undefined>;
+    readSomeContentBytes(start: number, end: number): Promise<Uint8Array | undefined>;
+    makeFileByteSource(): FileByteSource;
+}
+export interface Attrs {
+    ctime: number;
+    mtime: number;
+    size: number;
+    isEndless?: boolean;
+}
+export interface WritablePayload {
+    setXAttrs(xattrs: XAttrs): Promise<void>;
+    writeAllContent(bytes: Uint8Array[], xattrs?: XAttrs): Promise<void>;
+    makeFileByteSink(xattrs?: XAttrs): Promise<FileByteSink>;
+}
+export {};