core-3nweb-client-lib 0.27.3 → 0.27.5

package/build/lib-common/async-cryptor-wrap.js

@@ -23,6 +23,7 @@ const buffer_utils_1 = require("./buffer-utils");
  * This returns an encryptor that packs bytes according to "with-nonce" format,
  * keeping track and automatically advancing nonce.
  * @param cryptor is an async cryptor that will be used by created encryptor.
+ * @param workLabel
  * @param key for new encryptor.
  * Note that key will be copied, thus, if given array shall never be used
  * anywhere, it should be wiped after this call.
@@ -33,7 +34,7 @@ const buffer_utils_1 = require("./buffer-utils");
  * @param delta is a number between 1 and 255 inclusive, used to advance nonce.
  * When missing, it defaults to one.
  */
-function makeEncryptor(cryptor, key, nextNonce, delta) {
+function makeEncryptor(cryptor, workLabel, key, nextNonce, delta) {
     if (!(nextNonce instanceof Uint8Array)) {
         throw new TypeError("Nonce array nextNonce must be Uint8Array.");
     }
@@ -64,7 +65,7 @@ function makeEncryptor(cryptor, key, nextNonce, delta) {
             if (counter > counterMax) {
                 throw new Error(`This encryptor has been used too many times. Further use may lead to duplication of nonces.`);
             }
-            const c = await cryptor.formatWN.pack(m, nextNonce, key);
+            const c = await cryptor.formatWN.pack(m, nextNonce, key, workLabel);
             (0, xsp_files_1.advanceNonce)(nextNonce, delta);
             counter += 1;
             return c;
@@ -86,15 +87,14 @@ function makeEncryptor(cryptor, key, nextNonce, delta) {
 }
 exports.makeEncryptor = makeEncryptor;
 /**
- *
+ * @param cryptor
+ * @param workLabel
  * @param key for new decryptor.
- * @param arrFactory is typed arrays factory, used to allocated/find an array for use.
- * It may be undefined, in which case an internally created one is used.
- * Note that key will be copied, thus, if given array shall never be used anywhere,
- * it should be wiped after this call.
+ * Note that key will be copied, thus, if given array shall never be used
+ * anywhere, it should be wiped after this call.
  * @return a frozen object with pack & open and destroy functions.
  */
-function makeDecryptor(cryptor, key) {
+function makeDecryptor(cryptor, workLabel, key) {
     if (!(key instanceof Uint8Array)) {
         throw new TypeError("Key array key must be Uint8Array.");
     }
@@ -107,7 +107,7 @@ function makeDecryptor(cryptor, key) {
             if (!key) {
                 throw new Error(`This decryptor cannot be used, as it had already been destroyed.`);
             }
-            return cryptor.formatWN.open(c, key);
+            return cryptor.formatWN.open(c, key, workLabel);
         },
         destroy: () => {
             if (!key) {
@@ -120,16 +120,16 @@ function makeDecryptor(cryptor, key) {
     return Object.freeze(decryptor);
 }
 exports.makeDecryptor = makeDecryptor;
-function makeDecryptorForKeyPair(cryptor, pkey, skey) {
+function makeDecryptorForKeyPair(cryptor, workLabel, pkey, skey) {
     const dhSharedKey = ecma_nacl_1.box.calc_dhshared_key(pkey, skey);
-    const decryptor = makeDecryptor(cryptor, dhSharedKey);
+    const decryptor = makeDecryptor(cryptor, workLabel, dhSharedKey);
     dhSharedKey.fill(0);
     return decryptor;
 }
 exports.makeDecryptorForKeyPair = makeDecryptorForKeyPair;
-function makeEncryptorWithKeyPair(cryptor, pkey, skey, nextNonce, delta) {
+function makeEncryptorWithKeyPair(cryptor, workLabel, pkey, skey, nextNonce, delta) {
     const dhSharedKey = ecma_nacl_1.box.calc_dhshared_key(pkey, skey);
-    const decryptor = makeEncryptor(cryptor, dhSharedKey, nextNonce, delta);
+    const decryptor = makeEncryptor(cryptor, workLabel, dhSharedKey, nextNonce, delta);
     dhSharedKey.fill(0);
     return decryptor;
 }

package/build/lib-common/byte-streaming/pipe.d.ts

@@ -11,5 +11,5 @@ declare type FileByteSink = web3n.files.FileByteSink;
  * @param bufSize is an optional parameter for buffer, used for byte transfer.
  * Default value is 64K.
  */
-export declare function pipe(src: FileByteSource, sink: FileByteSink, progressCB?: ((bytesPiped: number) => void) | undefined, closeSink?: boolean, bufSize?: number): Promise<number>;
+export declare function pipe(src: FileByteSource, sink: FileByteSink, progressCB?: ((bytesPiped: number) => void), closeSink?: boolean, bufSize?: number): Promise<number>;
 export {};

package/build/lib-common/byte-streaming/pipe.js

@@ -28,10 +28,10 @@ const sink_utils_1 = require("../obj-streaming/sink-utils");
  * @param bufSize is an optional parameter for buffer, used for byte transfer.
  * Default value is 64K.
  */
-async function pipe(src, sink, progressCB = undefined, closeSink = true, bufSize = 64 * 1024) {
+async function pipe(src, sink, progressCB, closeSink = true, bufSize = 64 * 1024) {
     const contSink = (0, sink_utils_1.makeContinuousSink)(sink);
     try {
-        let buf = await src.read(bufSize);
+        let buf = await src.readNext(bufSize);
         let bytesPiped = 0;
         while (buf) {
             await contSink(buf);
@@ -39,7 +39,7 @@ async function pipe(src, sink, progressCB = undefined, closeSink = true, bufSize
             if (progressCB) {
                 progressCB(bytesPiped);
             }
-            buf = await src.read(bufSize);
+            buf = await src.readNext(bufSize);
         }
         if (closeSink) {
             await contSink(null);

package/build/lib-common/byte-streaming/wrapping.js

@@ -35,7 +35,8 @@ function wrapAndSyncSource(src) {
     const w = {
         getPosition: (0, synced_1.makeSyncedFunc)(syncProc, src, src.getPosition),
         getSize: (0, synced_1.makeSyncedFunc)(syncProc, src, src.getSize),
-        read: (0, synced_1.makeSyncedFunc)(syncProc, src, src.read),
+        readNext: (0, synced_1.makeSyncedFunc)(syncProc, src, src.readNext),
+        readAt: (0, synced_1.makeSyncedFunc)(syncProc, src, src.readAt),
         seek: (0, synced_1.makeSyncedFunc)(syncProc, src, src.seek)
     };
     return w;
@@ -46,7 +47,8 @@ function wrapAndSyncFileSource(src) {
     const w = {
         getPosition: (0, synced_1.makeSyncedFunc)(syncProc, src, src.getPosition),
         getSize: (0, synced_1.makeSyncedFunc)(syncProc, src, src.getSize),
-        read: (0, synced_1.makeSyncedFunc)(syncProc, src, src.read),
+        readNext: (0, synced_1.makeSyncedFunc)(syncProc, src, src.readNext),
+        readAt: (0, synced_1.makeSyncedFunc)(syncProc, src, src.readAt),
         seek: (0, synced_1.makeSyncedFunc)(syncProc, src, src.seek),
     };
     return w;

package/build/lib-common/json-utils.js

@@ -32,9 +32,6 @@ function copy(orig, excludeTopFields) {
     if (orig === null) {
         return null;
     }
-    if (Buffer.isBuffer(orig)) {
-        return orig;
-    }
     if (ArrayBuffer.isView(orig)) {
         return orig;
     }

package/build/lib-common/objs-on-disk/file-layout.js

@@ -83,7 +83,7 @@ class ObjVersionBytesLayout {
     isFileComplete() {
         for (const chunk of this.segsChunks) {
             if ((chunk.type === 'new') || (chunk.type === 'new-endless')) {
-                return true;
+                return false;
             }
         }
         return true;

package/build/lib-common/processes/synced.js

@@ -158,49 +158,6 @@ class SingleProc {
 exports.SingleProc = SingleProc;
 Object.freeze(SingleProc.prototype);
 Object.freeze(SingleProc);
-// export class DeduppedRunner<T> {
-// 	private proc: Promise<T>|undefined = undefined;
-// 	private waiting: Deferred<T>|undefined = undefined;
-// 	constructor(
-// 		private readonly action: Action<T>
-// 	) {
-// 		Object.seal(this);
-// 	}
-// 	trigger(): Promise<T> {
-// 		if (this.proc) {
-// 			if (!this.waiting) {
-// 				this.waiting = defer();
-// 			}
-// 			return this.waiting.promise;
-// 		} else {
-// 			this.proc = this.startAction();
-// 			return this.proc;
-// 		}
-// 	}
-// 	private async startAction(): Promise<T> {
-// 		const deferredBeforeStart = this.waiting;
-// 		this.waiting = undefined;
-// 		try {
-// 			const result = await this.action();
-// 			if (deferredBeforeStart) {
-// 				deferredBeforeStart.resolve(result);
-// 			}
-// 			return result;
-// 		} catch (err) {
-// 			if (deferredBeforeStart) {
-// 				deferredBeforeStart.reject(err);
-// 			}
-// 			throw err;
-// 		} finally {
-// 			this.proc = undefined;
-// 			if (this.waiting) {
-// 				this.proc = this.startAction();
-// 			}
-// 		}
-// 	}
-// }
-// Object.freeze(DeduppedRunner.prototype);
-// Object.freeze(DeduppedRunner);
 /**
  * This wraps given function/method into syncing wrap.
  */
@@ -208,145 +165,4 @@ function makeSyncedFunc(syncProc, thisArg, func) {
     return ((...args) => syncProc.startOrChain(() => func.apply(thisArg, args)));
 }
 exports.makeSyncedFunc = makeSyncedFunc;
-// export interface Deferred<T> {
-// 	promise: Promise<T>;
-// 	resolve: (result?: T|PromiseLike<T>) => void;
-// 	reject: (err: any) => void;
-// }
-// export function defer<T>(): Deferred<T> {
-// 	const d = <Deferred<T>> {};
-// 	d.promise = new Promise<T>((resolve, reject) => {
-// 		d.resolve = resolve;
-// 		d.reject = reject;
-// 	});
-// 	Object.freeze(d);
-// 	return d;
-// }
-// export class PressureValve {
-// 	private stopper: Deferred<void>|undefined = undefined;
-// 	constructor() {
-// 		Object.seal(this);
-// 	}
-// 	toggle(flag: boolean): void {
-// 		if (flag) {
-// 			if (this.stopper) { return; }
-// 			this.stopper = defer();
-// 		} else {
-// 			if (!this.stopper) { return; }
-// 			this.stopper.resolve();
-// 			this.stopper = undefined;
-// 		}
-// 	}
-// 	pressWithError(err: any): void {
-// 		this.toggle(true);
-// 		this.stopper!.reject(errWithCause(err, `Backpressure error`));
-// 	}
-// 	readonly pressure = async (): Promise<void> => {
-// 		if (!this.stopper) { return; }
-// 		await this.stopper.promise;
-// 	}
-// }
-// Object.freeze(PressureValve.prototype);
-// Object.freeze(PressureValve);
-// export function callWithTimeout<T>(
-// 	f: () => Promise<T>, timeout: number, timeoutErr: () => any
-// ): Promise<T> {
-// 	let isDone = false;
-// 	const deferred = defer<T>();
-// 	f().then(res => {
-// 		if (isDone) { return; }
-// 		isDone = true;
-// 		deferred.resolve(res);
-// 	}, err => {
-// 		if (isDone) { return; }
-// 		isDone = true;
-// 		deferred.reject(err);
-// 	});
-// 	sleep(timeout).then(() => {
-// 		if (isDone) { return; }
-// 		isDone = true;
-// 		const err = timeoutErr();
-// 		if (err) {
-// 			deferred.reject(err);
-// 		}
-// 	});
-// 	return deferred.promise;
-// }
-// export interface WorkerTask<WorkerLabel extends string> {
-// 	neededWorker(): WorkerLabel|undefined;
-// 	process(): Promise<void>;
-// 	cancel(): Promise<void>;
-// }
-// interface Worker {
-// 	readonly procs: Promise<void>[];
-// 	readonly maxProcs: number;
-// }
-// export class QueueAndWorkers<WorkerLabel extends string> {
-// 	private readonly queue: WorkerTask<WorkerLabel>[] = [];
-// 	private readonly workers = new Map<WorkerLabel, Worker>();
-// 	// private readonly set = new Set<WorkerTask>();
-// 	private isRunning = false;
-// 	// private readonly procs: Promise<void>[] = [];
-// 	// private maxProcs = 1;
-// 	constructor() {
-// 		Object.seal(this);
-// 	}
-// 	add(w: WorkerTask<WorkerLabel>, queueIfNotRunning = false): void {
-// 		if (this.isRunning) {
-// 			this.queue.push();
-// 			this.processNextQueued();
-// 		} else if (queueIfNotRunning) {
-// 			this.addToQueueOnce(w);
-// 		}
-// 	}
-// 	private addToQueueOnce(w: WorkerTask<WorkerLabel>): void {
-// 		if (!this.set.has(w)) {
-// 			this.queue.push(w);
-// 			this.set.add(w);
-// 		}
-// 	}
-// 	private getFromQueueHead(): WorkerTask<WorkerLabel>|undefined {
-// 		const w = this.queue.shift();
-// 		if (!w) { return; }
-// 		this.set.delete(w);
-// 		return w;
-// 	}
-// 	private async processNextQueued(): Promise<void> {
-// 		if (!this.isRunning || (this.procs.length >= this.maxProcs)) { return; }
-// 		const w = this.getFromQueueHead();
-// 		if (!w) { return; }
-// 		const proc = w.process();
-// 		this.procs.push(proc);
-// 		try {
-// 			await proc;
-// 		} finally {
-// 			const i = this.procs.indexOf(proc);
-// 			if (i >= 0) {
-// 				this.procs.splice(i, 1);
-// 			}
-// 			this.processNextQueued();
-// 		}
-// 	}
-// 	start(maxNumOfProcs = 1): void {
-// 		this.maxProcs = maxNumOfProcs;
-// 		this.isRunning = true;
-// 		this.processNextQueued();
-// 	}
-// 	pause(): void {
-// 		this.isRunning = false;
-// 	}
-// 	async stop(): Promise<void> {
-// 		this.isRunning = false;
-// 		const queue = this.queue.splice(0, this.queue.length);
-// 		this.set.clear();
-// 		for (const w of queue) {
-// 			await w.cancel();
-// 		}
-// 		while (this.procs.length > 0) {
-// 			await this.procs.pop();
-// 		}
-// 	}
-// }
-// Object.freeze(Worker.prototype);
-// Object.freeze(Worker);
 Object.freeze(exports);

package/build/lib-sqlite-on-3nstorage/index.d.ts

@@ -0,0 +1,32 @@
+import { Action, SingleProc } from '../lib-common/processes/synced';
+import { Database as DBClass, BindParams as QueryParams, QueryExecResult as QueryResult } from './sqljs';
+export declare type Database = DBClass;
+export declare type BindParams = QueryParams;
+export declare type QueryExecResult = QueryResult;
+declare type WritableFile = web3n.files.WritableFile;
+declare type ReadonlyFile = web3n.files.ReadonlyFile;
+export declare abstract class SQLiteOn3NStorage {
+    protected readonly database: Database;
+    protected readonly file: WritableFile;
+    protected readonly syncProc: SingleProc;
+    protected constructor(database: Database, file: WritableFile);
+    get db(): Database;
+    get dbFile(): WritableFile;
+    sync<T>(action: Action<T>): Promise<T>;
+    listTables(): string[];
+}
+export declare class SQLiteOnUnversionedFS extends SQLiteOn3NStorage {
+    static makeAndStart(file: WritableFile): Promise<SQLiteOnUnversionedFS>;
+    saveToFile(): Promise<void>;
+}
+export declare class SQLiteOnVersionedFS extends SQLiteOn3NStorage {
+    protected constructor(db: Database, file: WritableFile);
+    static makeAndStart(file: WritableFile): Promise<SQLiteOnVersionedFS>;
+    saveToFile(): Promise<number>;
+}
+export declare class SQLiteOnSyncedFS extends SQLiteOnVersionedFS {
+    protected constructor(db: Database, file: WritableFile);
+    static makeAndStart(file: WritableFile): Promise<SQLiteOnSyncedFS>;
+}
+export declare function readDbFrom(file: ReadonlyFile): Promise<Database>;
+export {};

package/build/lib-sqlite-on-3nstorage/index.js

@@ -0,0 +1,117 @@
+"use strict";
+/*
+ Copyright (C) 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.readDbFrom = exports.SQLiteOnSyncedFS = exports.SQLiteOnVersionedFS = exports.SQLiteOnUnversionedFS = exports.SQLiteOn3NStorage = void 0;
+const synced_1 = require("../lib-common/processes/synced");
+const sqljs_1 = require("./sqljs");
+class SQLiteOn3NStorage {
+    constructor(database, file) {
+        this.database = database;
+        this.file = file;
+        this.syncProc = new synced_1.SingleProc();
+    }
+    get db() {
+        return this.database;
+    }
+    get dbFile() {
+        return this.file;
+    }
+    sync(action) {
+        return this.syncProc.startOrChain(action);
+    }
+    listTables() {
+        const result = this.database.exec(`SELECT tbl_name FROM sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%'`);
+        return ((result.length > 0) ?
+            result[0].values.map(row => row[0]) :
+            []);
+    }
+}
+exports.SQLiteOn3NStorage = SQLiteOn3NStorage;
+Object.freeze(SQLiteOn3NStorage.prototype);
+Object.freeze(SQLiteOn3NStorage);
+class SQLiteOnUnversionedFS extends SQLiteOn3NStorage {
+    static async makeAndStart(file) {
+        const db = await readDbFrom(file);
+        return new SQLiteOnUnversionedFS(db, file);
+    }
+    async saveToFile() {
+        await this.syncProc.startOrChain(async () => {
+            const dbFileContent = this.database.export();
+            await this.file.writeBytes(dbFileContent);
+        });
+    }
+}
+exports.SQLiteOnUnversionedFS = SQLiteOnUnversionedFS;
+Object.freeze(SQLiteOnUnversionedFS.prototype);
+Object.freeze(SQLiteOnUnversionedFS);
+class SQLiteOnVersionedFS extends SQLiteOn3NStorage {
+    constructor(db, file) {
+        super(db, file);
+        if (!file.v) {
+            throw new Error(`Given file is not versioned`);
+        }
+    }
+    static async makeAndStart(file) {
+        const db = await readDbFrom(file);
+        return new SQLiteOnVersionedFS(db, file);
+    }
+    async saveToFile() {
+        return await this.syncProc.startOrChain(async () => {
+            const dbFileContent = this.database.export();
+            return await this.file.v.writeBytes(dbFileContent);
+        });
+    }
+}
+exports.SQLiteOnVersionedFS = SQLiteOnVersionedFS;
+Object.freeze(SQLiteOnVersionedFS.prototype);
+Object.freeze(SQLiteOnVersionedFS);
+class SQLiteOnSyncedFS extends SQLiteOnVersionedFS {
+    constructor(db, file) {
+        var _a;
+        super(db, file);
+        if (!((_a = file.v) === null || _a === void 0 ? void 0 : _a.sync)) {
+            throw new Error(`Given file is not synced`);
+        }
+    }
+    static async makeAndStart(file) {
+        const db = await readDbFrom(file);
+        return new SQLiteOnSyncedFS(db, file);
+    }
+}
+exports.SQLiteOnSyncedFS = SQLiteOnSyncedFS;
+Object.freeze(SQLiteOnSyncedFS.prototype);
+Object.freeze(SQLiteOnSyncedFS);
+async function readDbFrom(file) {
+    const SQL = await (0, sqljs_1.default)(true);
+    const fileContent = await readFileContent(file);
+    return new SQL.Database(fileContent);
+}
+exports.readDbFrom = readDbFrom;
+async function readFileContent(file) {
+    try {
+        return await file.readBytes();
+    }
+    catch (exc) {
+        if (exc.notFound) {
+            return undefined;
+        }
+        else {
+            throw exc;
+        }
+    }
+}