core-3nweb-client-lib 0.21.0 → 0.24.0

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 3NSoft Inc.
+ Copyright (C) 2017, 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,113 +13,117 @@
  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.deserializeFolderInfo = exports.serializeFolderInfo = void 0;
-/**
- * Everything in this module is assumed to be inside of a file system
- * reliance set.
- */
+exports.serializeFolderInfo = exports.parseFolderInfo = void 0;
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const xsp_files_1 = require("xsp-files");
-const error_1 = require("../../../lib-common/exceptions/error");
+const big_endian_1 = require("../../../lib-common/big-endian");
+const assert_1 = require("../../../lib-common/assert");
 const ver1Serialization = new Uint8Array([1]);
-function serializeFolderInfoV1(folderInfo) {
-    const bytes = [ver1Serialization];
-    Object.values(folderInfo.nodes)
-        .map(serializeNodeInfoV1)
-        .forEach(nodeBytes => bytes.push(...nodeBytes));
-    return bytes;
-}
-function serializeNodeInfoV1(nodeInfo) {
-    const bytes = [nodeInfo.key];
-    const json = {
-        t: (nodeInfo.isFolder ? 1 : (nodeInfo.isFile ? 2 : 3)),
-        n: nodeInfo.name,
-        o: nodeInfo.objId
-    };
-    const jsonBytes = buffer_utils_1.utf8.pack(JSON.stringify(json));
-    bytes.push(numberToBytes(jsonBytes.length));
-    bytes.push(jsonBytes);
-    return bytes;
-}
-function load_bigendian(arr) {
-    return (arr[3] | arr[2] << 8) | (arr[1] << 16) | (arr[0] << 24);
-}
-function store_bigendian(arr, x) {
-    if (x > 0xffffffff) {
-        throw new Error(`Number ${x} is bigger than expected unsigned 32 bit integer`);
+function parseFolderInfo(bytes) {
+    if (!bytes) {
+        throw parsingException(`Can't parse folder from no bytes`);
     }
-    arr[3] = x;
-    arr[2] = x >>> 8;
-    arr[1] = x >>> 16;
-    arr[0] = x >>> 24;
-}
-function numberToBytes(x) {
-    const arr = new Uint8Array(4);
-    store_bigendian(arr, x);
-    return arr;
-}
-function serializeFolderInfo(folderInfo) {
-    return serializeFolderInfoV1(folderInfo);
-}
-exports.serializeFolderInfo = serializeFolderInfo;
-function deserializeFolderInfo(bytes) {
     if (bytes[0] === ver1Serialization[0]) {
-        return deserializeFolderInfoV1(bytes.subarray(1));
+        return formatV1.parse(bytes.subarray(1));
     }
     else {
-        throw new Error(`Cannot recognize folder's serialization version`);
+        throw parsingException(`Cannot recognize folder's serialization version`);
     }
 }
-exports.deserializeFolderInfo = deserializeFolderInfo;
-function deserializeFolderInfoV1(bytes) {
-    let slice = bytes;
-    const folderInfo = {
-        nodes: {}
+exports.parseFolderInfo = parseFolderInfo;
+function serializeFolderInfo(folderInfo) {
+    return formatV1.pack(folderInfo);
+}
+exports.serializeFolderInfo = serializeFolderInfo;
+function parsingException(msg, cause) {
+    return {
+        runtimeException: true,
+        type: 'folder-parsing',
+        message: msg,
+        cause
     };
-    while (slice.length > 0) {
-        const { node, bytesRead } = deserializeNodeInfoV1(slice);
-        slice = slice.subarray(bytesRead);
-        folderInfo.nodes[node.name] = node;
-    }
-    bytes.fill(0);
-    return folderInfo;
 }
-function deserializeNodeInfoV1(bytes) {
-    if (bytes.length < (xsp_files_1.KEY_LENGTH + 4)) {
-        throw new Error(`Cannot deserialize node key from bytes`);
+var formatV1;
+(function (formatV1) {
+    function pack(folderInfo) {
+        const bytes = [ver1Serialization];
+        for (const nodeInfo of Object.values(folderInfo.nodes)) {
+            bytes.push(...packNode(nodeInfo));
+        }
+        return bytes;
+    }
+    formatV1.pack = pack;
+    function packNode(nodeInfo) {
+        const bytes = [nodeInfo.key];
+        const json = {
+            t: (nodeInfo.isFolder ? 1 : (nodeInfo.isFile ? 2 : 3)),
+            n: nodeInfo.name,
+            o: nodeInfo.objId
+        };
+        const jsonBytes = buffer_utils_1.utf8.pack(JSON.stringify(json));
+        assert_1.assert(jsonBytes.length < 0xffffffff);
+        bytes.push(numberToBytes(jsonBytes.length));
+        bytes.push(jsonBytes);
+        return bytes;
     }
-    const key = buffer_utils_1.makeUint8ArrayCopy(bytes.subarray(0, xsp_files_1.KEY_LENGTH));
-    bytes = bytes.subarray(xsp_files_1.KEY_LENGTH);
-    const jsonBytesLen = load_bigendian(bytes);
-    bytes = bytes.subarray(4);
-    try {
-        const json = JSON.parse(buffer_utils_1.utf8.open(bytes.subarray(0, jsonBytesLen)));
-        const node = {
-            name: json.n,
-            key,
-            objId: json.o
+    function numberToBytes(x) {
+        const arr = Buffer.allocUnsafe(4);
+        big_endian_1.packUintTo4Bytes(x, arr, 0);
+        return arr;
+    }
+    function parse(bytes) {
+        let slice = bytes;
+        const folderInfo = {
+            nodes: {}
         };
-        if (json.t === 1) {
-            node.isFolder = true;
+        while (slice.length > 0) {
+            const { node, bytesRead } = deserializeNodeInfoV1(slice);
+            slice = slice.subarray(bytesRead);
+            folderInfo.nodes[node.name] = node;
         }
-        else if (json.t === 2) {
-            node.isFile = true;
+        bytes.fill(0);
+        return folderInfo;
+    }
+    formatV1.parse = parse;
+    function deserializeNodeInfoV1(bytes) {
+        if (bytes.length < (xsp_files_1.KEY_LENGTH + 4)) {
+            throw parsingException(`Cannot deserialize node key from bytes`);
         }
-        else if (json.t === 3) {
-            node.isLink = true;
+        const key = buffer_utils_1.makeUint8ArrayCopy(bytes.subarray(0, xsp_files_1.KEY_LENGTH));
+        bytes = bytes.subarray(xsp_files_1.KEY_LENGTH);
+        const jsonBytesLen = big_endian_1.uintFrom4Bytes(bytes);
+        bytes = bytes.subarray(4);
+        try {
+            const json = JSON.parse(buffer_utils_1.utf8.open(bytes.subarray(0, jsonBytesLen)));
+            const node = {
+                name: json.n,
+                key,
+                objId: json.o
+            };
+            if (json.t === 1) {
+                node.isFolder = true;
+            }
+            else if (json.t === 2) {
+                node.isFile = true;
+            }
+            else if (json.t === 3) {
+                node.isLink = true;
+            }
+            else {
+                throw parsingException('unidentified node type');
+            }
+            return {
+                node,
+                bytesRead: xsp_files_1.KEY_LENGTH + 4 + jsonBytesLen
+            };
         }
-        else {
-            throw 'unidentified node type';
+        catch (err) {
+            throw parsingException(`Cannot deserialize node info from bytes.`, err);
         }
-        return {
-            node,
-            bytesRead: xsp_files_1.KEY_LENGTH + 4 + jsonBytesLen
-        };
     }
-    catch (err) {
-        throw error_1.errWithCause(err, `Cannot deserialize node info from bytes.`);
-    }
-}
+})(formatV1 || (formatV1 = {}));
+Object.freeze(formatV1);
 Object.freeze(exports);

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

@@ -1,11 +1,13 @@
 import { Storage, Node, NodeType } from './common';
-import { NodeInFS, NodeCrypto } from './node-in-fs';
+import { NodeInFS } from './node-in-fs';
 import { FileNode } from './file-node';
 import { LinkNode } from './link-node';
 import { LinkParameters } from '../../files';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
-import { FolderAttrs, AttrsHolder, EntityAttrs } from '../../files/file-attrs';
+import { CommonAttrs, XAttrs } from './attrs';
+import { NodePersistance } from './node-persistence';
 declare type ListingEntry = web3n.files.ListingEntry;
+declare type XAttrsChanges = web3n.files.XAttrsChanges;
 export interface NodeInfo {
     /**
      * This is a usual file name.
@@ -40,15 +42,17 @@ export interface FolderInfo {
         [name: string]: NodeInfo;
     };
 }
-export interface FolderInfoWithAttrs extends FolderInfo {
-    attrs?: FolderAttrs;
+export interface FolderInJSON extends FolderInfo {
+    ctime: number;
+    xattrs?: any;
 }
-declare class FolderCrypto extends NodeCrypto {
+declare class FolderPersistance extends NodePersistance {
     constructor(zNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
-    pack(folderInfo: FolderInfo, version: number, attrs: AttrsHolder<FolderAttrs>): Promise<Subscribe>;
-    open(src: ObjSource): Promise<{
+    write(folderInfo: FolderInfo, version: number, attrs: CommonAttrs, xattrs: XAttrs | undefined): Promise<Subscribe>;
+    read(src: ObjSource): Promise<{
         folderInfo: FolderInfo;
-        attrs?: AttrsHolder<FolderAttrs>;
+        attrs: CommonAttrs;
+        xattrs?: XAttrs;
     }>;
 }
 export interface FolderLinkParams {
@@ -56,17 +60,14 @@ export interface FolderLinkParams {
     objId: string;
     fKey: string;
 }
-export declare class FolderNode extends NodeInFS<FolderCrypto, FolderAttrs> {
+export declare class FolderNode extends NodeInFS<FolderPersistance> {
     private currentState;
-    private transitionState;
-    private transitionVersion;
-    private transitionSaved;
     private constructor();
     static newRoot(storage: Storage, key: Uint8Array): Promise<FolderNode>;
     static rootFromObjBytes(storage: Storage, name: string | undefined, objId: string | null, src: ObjSource, key: Uint8Array): Promise<FolderNode>;
     private static readNodeFromObjBytes;
     static rootFromLinkParams(storage: Storage, params: FolderLinkParams): Promise<FolderNode>;
-    static rootFromJSON(storage: Storage, name: string | undefined, folderJson: FolderInfoWithAttrs): FolderNode;
+    static rootFromJSON(storage: Storage, name: string | undefined, folderJson: FolderInJSON): FolderNode;
     list(): {
         lst: ListingEntry[];
         version: number;
@@ -88,21 +89,15 @@ export declare class FolderNode extends NodeInFS<FolderCrypto, FolderAttrs> {
     private fixMissingChildAndThrow;
     /**
      * This method prepares a transition state, runs given action, and completes
-     * transition to a new version. Returned promise resolves to whatever given
-     * action returns (promise is unwrapped).
+     * transition to a new version.
      * Note that if there is already an ongoing change, this transition will
      * wait. Such behaviour is generally needed for folder as different processes
      * may be sharing same elements in a file tree. In contrast, file
      * operations should more often follow a throw instead wait approach.
-     * @param autoSave true value turns on saving in of transition by this call,
-     * while false value indicates that saving will be done within a given action
-     * @param action is a function that is run when transition is started
+     * @param change is a function that is run when transition is started
      */
     private doTransition;
-    private wrapInTransition;
-    private clearTransitionState;
-    private saveTransitionState;
-    private addToTransitionState;
+    private performTransition;
     /**
      * This function only creates folder node, but it doesn't insert it anywhere.
      * @param name
@@ -121,10 +116,10 @@ export declare class FolderNode extends NodeInFS<FolderCrypto, FolderAttrs> {
      */
     private makeAndSaveNewChildLinkNode;
     private create;
-    createFolder(name: string, exclusive: boolean): Promise<FolderNode>;
+    createFolder(name: string, exclusive: boolean, changes: XAttrsChanges | undefined): Promise<FolderNode>;
     createFile(name: string, exclusive: boolean): Promise<FileNode>;
     createLink(name: string, params: LinkParameters<any>): Promise<void>;
-    removeChild(f: NodeInFS<NodeCrypto, EntityAttrs>): Promise<void>;
+    removeChild(f: NodeInFS<any>): Promise<void>;
     private changeChildName;
     moveChildTo(childName: string, dst: FolderNode, nameInDst: string): Promise<void>;
     private moveChildOut;