core-3nweb-client-lib 0.20.7 → 0.22.0

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

@@ -0,0 +1,337 @@
+"use strict";
+/*
+ Copyright (C) 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
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ 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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XAttrs = exports.CommonAttrs = void 0;
+const assert_1 = require("../../../lib-common/assert");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const big_endian_1 = require("../../../lib-common/big-endian");
+class CommonAttrs {
+    constructor(ctime, mtime) {
+        this.ctime = ctime;
+        this.mtime = mtime;
+        Object.seal(this);
+    }
+    static makeForTimeNow() {
+        const now = Date.now();
+        return new CommonAttrs(now, now);
+    }
+    static fromAttrs(attrs) {
+        return new CommonAttrs(attrs.ctime, attrs.mtime);
+    }
+    static parse(bytes) {
+        if (bytes.length < CommonAttrs.PACK_LEN) {
+            throw parsingException(`byte array is too short`);
+        }
+        const ctime = big_endian_1.uintFrom6Bytes(bytes, 0);
+        const mtime = big_endian_1.uintFrom6Bytes(bytes, 6);
+        return new CommonAttrs(ctime, mtime);
+    }
+    pack() {
+        const bytes = Buffer.allocUnsafe(CommonAttrs.PACK_LEN);
+        big_endian_1.packUintTo6Bytes(this.ctime, bytes, 0);
+        big_endian_1.packUintTo6Bytes(this.mtime, bytes, 6);
+        return bytes;
+    }
+    copy() {
+        return new CommonAttrs(this.ctime, this.mtime);
+    }
+    updateMTime() {
+        this.mtime = Date.now();
+    }
+}
+exports.CommonAttrs = CommonAttrs;
+CommonAttrs.PACK_LEN = 6 + 6;
+Object.freeze(CommonAttrs.prototype);
+Object.freeze(CommonAttrs);
+class XAttrs {
+    constructor() {
+        this.attrs = new Map();
+        Object.seal(this);
+    }
+    static makeEmpty() {
+        return new XAttrs();
+    }
+    static parseFrom(sections) {
+        const xattrs = new XAttrs();
+        for (const bytes of sections) {
+            let i = 0;
+            while (i < bytes.length) {
+                const { bytesRead, binVal, strVal, jsonVal, xaName } = extAttrs.readNamedAttr(buffer_utils_1.toBuffer(bytes), i);
+                xattrs.attrs.set(xaName, { binVal, strVal, jsonVal });
+                i += bytesRead;
+            }
+        }
+        return xattrs;
+    }
+    copy() {
+        const copy = new XAttrs();
+        for (const [xaName, xaVal] of this.attrs.entries()) {
+            copy.attrs.set(xaName, xaVal);
+        }
+        return copy;
+    }
+    makeUpdated(changes) {
+        const updated = this.copy();
+        if (changes.remove && (changes.remove.length > 0)) {
+            for (const xaName of changes.remove) {
+                updated.attrs.delete(xaName);
+            }
+        }
+        if (changes.set && (Object.keys(changes.set).length > 0)) {
+            for (const [xaName, value] of Object.entries(changes.set)) {
+                if (typeof value === 'string') {
+                    updated.attrs.set(xaName, { strVal: value });
+                }
+                else if (Buffer.isBuffer(value) || ArrayBuffer.isView(value)) {
+                    updated.attrs.set(xaName, { binVal: value });
+                }
+                else if (value !== undefined) {
+                    updated.attrs.set(xaName, { jsonVal: value });
+                }
+            }
+        }
+        return updated;
+    }
+    get(xaName) {
+        const val = this.attrs.get(xaName);
+        if (!val) {
+            return;
+        }
+        else if (val.strVal !== undefined) {
+            return val.strVal;
+        }
+        else if (val.binVal) {
+            return val.binVal;
+        }
+        else if (val.jsonVal !== undefined) {
+            return val.jsonVal;
+        }
+    }
+    list() {
+        return Array.from(this.attrs.keys());
+    }
+    get isEmpty() {
+        return (this.attrs.size === 0);
+    }
+    pack() {
+        if (this.isEmpty) {
+            return;
+        }
+        const bytes = [];
+        for (const [xaName, v] of this.attrs.entries()) {
+            if (v.strVal !== undefined) {
+                bytes.push(extAttrs.packNamedStrAttr(xaName, v.strVal));
+            }
+            else if (v.binVal) {
+                bytes.push(extAttrs.packNamedBinaryAttr(xaName, v.binVal));
+            }
+            else {
+                assert_1.assert(v.jsonVal !== undefined);
+                bytes.push(extAttrs.packNamedJsonAttr(xaName, v.jsonVal));
+            }
+        }
+        return bytes;
+    }
+}
+exports.XAttrs = XAttrs;
+Object.freeze(XAttrs.prototype);
+Object.freeze(XAttrs);
+var extAttrs;
+(function (extAttrs) {
+    const NAMED_BINARY = 1;
+    const NAMED_UTF8_STR = 2;
+    const NAMED_JSON = 3;
+    function readNamedAttr(bytes, i) {
+        const t = parseTypeByte(bytes[i]);
+        let ofs = i + 1;
+        const nameLen = readLenNum(bytes, ofs, t.nameLen);
+        ofs += t.nameLen;
+        const contentLen = readLenNum(bytes, ofs, t.contentLen);
+        ofs += t.contentLen;
+        const xaName = bytes.slice(ofs, ofs + nameLen).toString('utf8');
+        ofs += nameLen;
+        const bytesRead = ofs - i + contentLen;
+        if ((contentLen === 0) || (bytes.length < (i + bytesRead))) {
+            throw parsingException(`Unexpected end of byte array`);
+        }
+        try {
+            if (t.type === NAMED_UTF8_STR) {
+                return {
+                    bytesRead, xaName,
+                    strVal: bytes.slice(ofs, ofs + contentLen).toString('utf8'),
+                };
+            }
+            else if (t.type === NAMED_JSON) {
+                return {
+                    bytesRead, xaName,
+                    jsonVal: JSON.parse(buffer_utils_1.toBuffer(bytes).slice(ofs, ofs + contentLen).toString('utf8')),
+                };
+            }
+            else if (t.type === NAMED_BINARY) {
+                return {
+                    bytesRead, xaName,
+                    binVal: bytes.slice(ofs, ofs + contentLen),
+                };
+            }
+            else {
+                throw new Error(`Unknown type ${t.type} of named attribute`);
+            }
+        }
+        catch (err) {
+            throw parsingException(`Error in parsing `, err);
+        }
+    }
+    extAttrs.readNamedAttr = readNamedAttr;
+    function parseTypeByte(b) {
+        const type = ((b & 0b11111000) >> 5);
+        const nameLen = ((b & 0b00000100) >> 2) + 1;
+        const contentLen = (b & 0b00000011) + 1;
+        return { type, contentLen, nameLen };
+    }
+    function readLenNum(bytes, i, len) {
+        switch (len) {
+            case 1:
+                return bytes[i];
+            case 2:
+                return big_endian_1.uintFrom2Bytes(bytes, i);
+            case 3:
+                return big_endian_1.uintFrom3Bytes(bytes, i);
+            case 4:
+                return big_endian_1.uintFrom4Bytes(bytes, i);
+            default:
+                throw parsingException(`Too many bytes for xattr length`);
+        }
+    }
+    function packNamedStrAttr(name, value) {
+        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
+            (typeof value === 'string') && (value.length > 0));
+        const nameBin = Buffer.from(name, 'utf8');
+        const valueBin = Buffer.from(value, 'utf8');
+        return packNamedAttr(NAMED_UTF8_STR, nameBin, valueBin);
+    }
+    extAttrs.packNamedStrAttr = packNamedStrAttr;
+    function packNamedBinaryAttr(name, value) {
+        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
+            (value.length > 0));
+        const nameBin = Buffer.from(name, 'utf8');
+        return packNamedAttr(NAMED_BINARY, nameBin, value);
+    }
+    extAttrs.packNamedBinaryAttr = packNamedBinaryAttr;
+    function packNamedJsonAttr(name, value) {
+        assert_1.assert((typeof name === 'string') && (name.length > 0) &&
+            (value !== undefined));
+        const nameBin = Buffer.from(name, 'utf8');
+        const valueBin = Buffer.from(JSON.stringify(value), 'utf8');
+        return packNamedAttr(NAMED_JSON, nameBin, valueBin);
+    }
+    extAttrs.packNamedJsonAttr = packNamedJsonAttr;
+    function packNamedAttr(type, name, value) {
+        const nameLenLen = byteToStoreLen(name.length);
+        if (nameLenLen > 2) {
+            throw new Error(`Name is too long to pack`);
+        }
+        const contentLenLen = byteToStoreLen(value.length);
+        if (contentLenLen > 4) {
+            throw new Error(`Value is too long to pack`);
+        }
+        const b = Buffer.allocUnsafe(1 + nameLenLen + contentLenLen + name.length + value.length);
+        // first byte contains, left to right:
+        //  - 5 bits with type,
+        //  - 1 bits with number of bytes for name length, and
+        //  - 2 bits with number of bytes for value length
+        b[0] = (type << 3) | ((nameLenLen - 1) << 2) | (contentLenLen - 1);
+        // bytes with length of name
+        let i = 1;
+        packUint(name.length, b, i, nameLenLen);
+        // bytes with length of content
+        i += nameLenLen;
+        packUint(value.length, b, i, contentLenLen);
+        // bytes with name
+        i += contentLenLen;
+        b.set(name, i);
+        // bytes with content
+        i += name.length;
+        b.set(value, i);
+        return b;
+    }
+    function byteToStoreLen(len) {
+        if (len <= 0xff) {
+            return 1;
+        }
+        else if (len <= 0xffff) {
+            return 2;
+        }
+        else if (len <= 0xffffff) {
+            return 3;
+        }
+        else if (len <= 0xffffffff) {
+            return 4;
+        }
+        else {
+            return 5;
+        }
+    }
+    function packUint(u, b, i, byteToUse) {
+        switch (byteToUse) {
+            case 1:
+                b[i] = u;
+                break;
+            case 2:
+                big_endian_1.packUintTo2Bytes(u, b, i);
+                break;
+            case 3:
+                big_endian_1.packUintTo3Bytes(u, b, i);
+                break;
+            case 4:
+                big_endian_1.packUintTo4Bytes(u, b, i);
+                break;
+            default:
+                assert_1.assert(false);
+        }
+    }
+    // export function pack(xattrs: XAttrs): Buffer {
+    // 	const ext: Buffer[] = [];
+    // 	for (const xattr of Object.values(xattrs)) {
+    // 		if (xattr.type === 'named-utf8str') {
+    // 			ext.push(packNamedStrAttr(xattr.name, xattr.value));
+    // 		} else if (xattr.type === 'named-json') {
+    // 			ext.push(packNamedJsonAttr(xattr.name, xattr.value));
+    // 		} else if (xattr.type === 'named-binary') {
+    // 			ext.push(packNamedBinaryAttr(xattr.name, xattr.value));
+    // 		} else {
+    // 			throw new Error(`Unknown type of named attribute`);
+    // 		}
+    // 	}
+    // 	const bytes = Buffer.allocUnsafe(ext.reduce((len, b) => len+b.length, 0));
+    // 	let ofs = 0;
+    // 	for (const buf of ext) {
+    // 		bytes.set(buf, ofs);
+    // 		ofs += buf.length;
+    // 	}
+    // 	return bytes;
+    // }
+})(extAttrs || (extAttrs = {}));
+Object.freeze(extAttrs);
+function parsingException(msg, cause) {
+    return {
+        runtimeException: true,
+        type: 'attrs-parsing',
+        cause, msg
+    };
+}
+Object.freeze(exports);

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

@@ -2,7 +2,7 @@ import { ScryptGenParams } from '../../key-derivation';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
 import { objChanged, objRemoved } from '../../../lib-common/service-api/3nstorage/owner';
 export { AsyncSBoxCryptor } from 'xsp-files';
-export { FolderInfoWithAttrs } from './folder-node';
+export { FolderInJSON } from './folder-node';
 declare type StorageType = web3n.files.FSType;
 export interface RemoteObjRemovalEvent extends objRemoved.Event {
     type: 'remote-delete';

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2017, 2019 - 2020 3NSoft Inc.
+ Copyright (C) 2015 - 2017, 2019 - 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.wrapSyncStorageImplementation = exports.wrapStorageImplementation = exports.NodesContainer = void 0;
 /**

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

@@ -2,28 +2,34 @@
  * 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 { Subscribe, ObjSource, ByteSource } from 'xsp-files';
-import { FileAttrs, AttrsHolder } from '../../files/file-attrs';
+import { Subscribe, ObjSource } from 'xsp-files';
+import { CommonAttrs, XAttrs } from './attrs';
+import { NodePersistance } from './node-persistence';
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
-declare class FileCrypto extends NodeCrypto {
+declare type XAttrsChanges = web3n.files.XAttrsChanges;
+interface FileAttrs {
+    attrs: CommonAttrs;
+    size: number;
+    xattrs?: XAttrs;
+}
+declare class FilePersistance extends NodePersistance {
     constructor(zNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
-    getAttrsAndByteSrc(src: ObjSource): Promise<{
-        attrs?: AttrsHolder<FileAttrs>;
-        attrsByteSize?: number;
-        byteSrc: ByteSource;
+    getAttrs(objSrc: ObjSource): Promise<FileAttrs>;
+    getFileSource(objSrc: ObjSource, getAttrs?: boolean): Promise<{
+        src: FileByteSource;
+        fileAttrs?: FileAttrs;
     }>;
-    decryptedBytesSource(src: ObjSource): Promise<{
-        fileSrc: FileByteSource;
-        attrs?: AttrsHolder<FileAttrs>;
+    readBytes(objSrc: ObjSource, start: number | undefined, end: number | undefined, getAttrs?: boolean): Promise<{
+        bytes?: Uint8Array;
+        fileAttrs?: FileAttrs;
     }>;
-    saveBytes(bytes: Uint8Array | Uint8Array[], version: number, attrs: AttrsHolder<any>): Promise<Subscribe>;
-    encryptingByteSink(version: number, attrs: AttrsHolder<FileAttrs>, base: ObjSource | undefined): Promise<{
-        sinkDef: Promise<FileByteSink>;
-        cancelSinkDef: (err: any) => void;
+    saveBytes(bytes: Uint8Array | Uint8Array[], version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined): Promise<Subscribe>;
+    getFileSink(version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined, base: ObjSource | undefined): Promise<{
+        sinkPromise: Promise<FileByteSink>;
         sub: Subscribe;
     }>;
 }
@@ -32,23 +38,30 @@ export interface FileLinkParams {
     objId: string;
     fKey: string;
 }
-export declare class FileNode extends NodeInFS<FileCrypto, FileAttrs> {
+export declare class FileNode extends NodeInFS<FilePersistance> {
+    private fileSize;
     private constructor();
     static makeForNew(storage: Storage, parentId: string, name: string, key: Uint8Array): Promise<FileNode>;
     static makeForExisting(storage: Storage, parentId: string, fileName: string, objId: string, key: Uint8Array): Promise<FileNode>;
     static makeFromLinkParams(storage: Storage, params: FileLinkParams): Promise<FileNode>;
     private static initWithAttrs;
+    private setUpdatedState;
+    get size(): number;
     readSrc(): Promise<{
         src: FileByteSource;
         version: number;
     }>;
-    writeSink(truncate: boolean | undefined, currentVersion: number | undefined): Promise<{
+    readBytes(start: number | undefined, end: number | undefined): Promise<{
+        bytes: Uint8Array | undefined;
+        version: number;
+    }>;
+    writeSink(truncate: boolean | undefined, currentVersion: number | undefined, changes?: XAttrsChanges): Promise<{
         sink: FileByteSink;
         version: number;
     }>;
     private startMakingSinkInsideChange;
     private savingObjInsideChange;
-    save(bytes: Uint8Array | Uint8Array[]): Promise<number>;
+    save(bytes: Uint8Array | Uint8Array[], changes?: XAttrsChanges): Promise<number>;
     getParamsForLink(): LinkParameters<FileLinkParams>;
 }
 export {};