@milaboratories/pl-client 2.17.7 → 2.17.9

package/dist/core/client.js

@@ -1,292 +1,260 @@
-import { LLPlClient } from './ll_client.js';
-import { toGlobalResourceId, PlTransaction, TxCommitConflict } from './transaction.js';
-import { createHash } from 'node:crypto';
-import { NullResourceId, isNullResourceId, ensureResourceIdNotNull } from './types.js';
-import { ClientRoot } from '../helpers/pl.js';
-import { assertNever, createRetryState, nextRetryStateOrError } from '@milaboratories/ts-helpers';
-import { MaintenanceAPI_Ping_Response_Compression } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.js';
-import * as tp from 'node:timers/promises';
-import { LRUCache } from 'lru-cache';
-import { DefaultFinalResourceDataPredicate } from './final.js';
-import { initialTxStat, addStat } from './stat.js';
-import { advisoryLock } from './advisory_locks.js';
-import { plAddressToConfig } from './config.js';
+import { NullResourceId, ensureResourceIdNotNull, isNullResourceId } from "./types.js";
+import { MaintenanceAPI_Ping_Response_Compression } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.js";
+import { addStat, initialTxStat } from "./stat.js";
+import { PlTransaction, TxCommitConflict, toGlobalResourceId } from "./transaction.js";
+import { ClientRoot } from "../helpers/pl.js";
+import { plAddressToConfig } from "./config.js";
+import { LLPlClient } from "./ll_client.js";
+import { DefaultFinalResourceDataPredicate } from "./final.js";
+import { advisoryLock } from "./advisory_locks.js";
+import { assertNever, createRetryState, nextRetryStateOrError } from "@milaboratories/ts-helpers";
+import { createHash } from "node:crypto";
+import * as tp from "node:timers/promises";
+import { LRUCache } from "lru-cache";
 
-const defaultTxOps = {
-    sync: false,
-};
+//#region src/core/client.ts
+const defaultTxOps = { sync: false };
 const AnonymousClientRoot = "AnonymousRoot";
 function alternativeRootFieldName(alternativeRoot) {
-    return `alternative_root_${alternativeRoot}`;
+	return `alternative_root_${alternativeRoot}`;
 }
 /** Client to access core PL API. */
-class PlClient {
-    drivers = new Map();
-    /** Artificial delay introduced after write transactions completion, to
-     * somewhat throttle the load on pl. Delay introduced after sync, if requested. */
-    txDelay;
-    /** Last resort measure to solve complicated race conditions in pl. */
-    forceSync;
-    /** Last resort measure to solve complicated race conditions in pl. */
-    defaultRetryOptions;
-    buildLLPlClient;
-    _ll;
-    get ll() {
-        if (this._ll === undefined) {
-            throw new Error("LLPlClient not initialized");
-        }
-        return this._ll;
-    }
-    /** Stores client root (this abstraction is intended for future implementation of the security model) */
-    _clientRoot = NullResourceId;
-    _serverInfo = undefined;
-    _txCommittedStat = initialTxStat();
-    _txConflictStat = initialTxStat();
-    _txErrorStat = initialTxStat();
-    //
-    // Caching
-    //
-    /** This function determines whether resource data can be cached */
-    finalPredicate;
-    /** Resource data cache, to minimize redundant data rereading from remote db */
-    resourceDataCache;
-    constructor(configOrAddress, auth, ops = {}) {
-        const conf = typeof configOrAddress === "string" ? plAddressToConfig(configOrAddress) : configOrAddress;
-        this.buildLLPlClient = async (shouldUseGzip, wireProtocol) => {
-            if (wireProtocol)
-                conf.wireProtocol = wireProtocol;
-            return await LLPlClient.build(conf, { auth, ...ops, shouldUseGzip });
-        };
-        this.txDelay = conf.txDelay;
-        this.forceSync = conf.forceSync;
-        this.finalPredicate = ops.finalPredicate ?? DefaultFinalResourceDataPredicate;
-        this.resourceDataCache = new LRUCache({
-            maxSize: conf.maxCacheBytes,
-            sizeCalculation: (v) => (v.basicData.data?.length ?? 0) + 64,
-        });
-        switch (conf.retryBackoffAlgorithm) {
-            case "exponential":
-                this.defaultRetryOptions = {
-                    type: "exponentialBackoff",
-                    initialDelay: conf.retryInitialDelay,
-                    maxAttempts: conf.retryMaxAttempts,
-                    backoffMultiplier: conf.retryExponentialBackoffMultiplier,
-                    jitter: conf.retryJitter,
-                };
-                break;
-            case "linear":
-                this.defaultRetryOptions = {
-                    type: "linearBackoff",
-                    initialDelay: conf.retryInitialDelay,
-                    maxAttempts: conf.retryMaxAttempts,
-                    backoffStep: conf.retryLinearBackoffStep,
-                    jitter: conf.retryJitter,
-                };
-                break;
-            default:
-                assertNever(conf.retryBackoffAlgorithm);
-        }
-    }
-    get txCommittedStat() {
-        return { ...this._txCommittedStat };
-    }
-    get txConflictStat() {
-        return { ...this._txConflictStat };
-    }
-    get txErrorStat() {
-        return { ...this._txErrorStat };
-    }
-    get txTotalStat() {
-        return addStat(addStat(this._txCommittedStat, this._txConflictStat), this._txErrorStat);
-    }
-    get allTxStat() {
-        return {
-            committed: this.txCommittedStat,
-            conflict: this.txConflictStat,
-            error: this.txErrorStat,
-        };
-    }
-    async ping() {
-        return await this.ll.ping();
-    }
-    async license() {
-        return await this.ll.license();
-    }
-    get conf() {
-        return this.ll.conf;
-    }
-    get httpDispatcher() {
-        return this.ll.httpDispatcher;
-    }
-    get connectionOpts() {
-        return this.ll.wireConnection;
-    }
-    get initialized() {
-        return !isNullResourceId(this._clientRoot);
-    }
-    checkInitialized() {
-        if (!this.initialized)
-            throw new Error("Client not initialized");
-    }
-    get clientRoot() {
-        this.checkInitialized();
-        return ensureResourceIdNotNull(this._clientRoot);
-    }
-    get serverInfo() {
-        this.checkInitialized();
-        return this._serverInfo;
-    }
-    /** Currently implements custom logic to emulate future behaviour with single root. */
-    async init() {
-        if (this.initialized)
-            throw new Error("Already initialized");
-        // Initial client is created without gzip to perform server ping and detect optimal wire protocol.
-        // LLPlClient.build() internally calls detectOptimalWireProtocol() which starts with default 'grpc',
-        // then retries with 'rest' if ping fails, alternating until a working protocol is found.
-        // We save the detected wireProtocol here because if the server supports gzip compression,
-        // we'll need to reinitialize the client with gzip enabled - passing the already-detected
-        // wireProtocol avoids redundant protocol detection on reinit.
-        this._ll = await this.buildLLPlClient(false);
-        const wireProtocol = this._ll.wireProtocol;
-        // calculating reproducible root name from the username
-        const user = this._ll.authUser;
-        const mainRootName = user === null ? AnonymousClientRoot : createHash("sha256").update(user).digest("hex");
-        this._serverInfo = await this.ping();
-        if (this._serverInfo.compression === MaintenanceAPI_Ping_Response_Compression.GZIP) {
-            await this._ll.close();
-            this._ll = await this.buildLLPlClient(true, wireProtocol);
-        }
-        this._clientRoot = await this._withTx("initialization", true, NullResourceId, async (tx) => {
-            let mainRoot;
-            if (await tx.checkResourceNameExists(mainRootName))
-                mainRoot = await tx.getResourceByName(mainRootName);
-            else {
-                mainRoot = tx.createRoot(ClientRoot);
-                tx.setResourceName(mainRootName, mainRoot);
-            }
-            if (this.conf.alternativeRoot === undefined) {
-                await tx.commit();
-                return await toGlobalResourceId(mainRoot);
-            }
-            else {
-                const aFId = {
-                    resourceId: mainRoot,
-                    fieldName: alternativeRootFieldName(this.conf.alternativeRoot),
-                };
-                const altRoot = tx.createEphemeral(ClientRoot);
-                tx.lock(altRoot);
-                tx.createField(aFId, "Dynamic");
-                tx.setField(aFId, altRoot);
-                await tx.commit();
-                return await altRoot.globalId;
-            }
-        });
-    }
-    /** Returns true if field existed */
-    async deleteAlternativeRoot(alternativeRootName) {
-        this.checkInitialized();
-        if (this.ll.conf.alternativeRoot !== undefined)
-            throw new Error("Initialized with alternative root.");
-        return await this.withWriteTx("delete-alternative-root", async (tx) => {
-            const fId = {
-                resourceId: tx.clientRoot,
-                fieldName: alternativeRootFieldName(alternativeRootName),
-            };
-            const exists = tx.fieldExists(fId);
-            tx.removeField(fId);
-            await tx.commit();
-            return await exists;
-        });
-    }
-    async _withTx(name, writable, clientRoot, body, ops) {
-        // for exponential / linear backoff
-        let retryState = createRetryState(ops?.retryOptions ?? this.defaultRetryOptions);
-        while (true) {
-            const release = ops?.lockId ? await advisoryLock(ops.lockId) : () => { };
-            try {
-                // opening low-level tx
-                const llTx = this.ll.createTx(writable, ops);
-                // wrapping it into high-level tx (this also asynchronously sends initialization message)
-                const tx = new PlTransaction(llTx, name, writable, clientRoot, this.finalPredicate, this.resourceDataCache);
-                let ok = false;
-                let result = undefined;
-                let txId;
-                try {
-                    // executing transaction body
-                    result = await body(tx);
-                    // collecting stat
-                    this._txCommittedStat = addStat(this._txCommittedStat, tx.stat);
-                    ok = true;
-                }
-                catch (e) {
-                    // the only recoverable
-                    if (e instanceof TxCommitConflict) {
-                        // ignoring
-                        // collecting stat
-                        this._txConflictStat = addStat(this._txConflictStat, tx.stat);
-                    }
-                    else {
-                        // collecting stat
-                        this._txErrorStat = addStat(this._txErrorStat, tx.stat);
-                        throw e;
-                    }
-                }
-                finally {
-                    // close underlying grpc stream, if not yet done
-                    // even though we can skip two lines below for read-only transactions,
-                    // we don't do it to simplify reasoning about what is going on in
-                    // concurrent code, especially in significant latency situations
-                    await tx.complete();
-                    await tx.await();
-                    txId = await tx.getGlobalTxId();
-                }
-                if (ok) {
-                    // syncing on transaction if requested
-                    if (ops?.sync === undefined ? this.forceSync : ops?.sync)
-                        await this.ll.txSync(txId);
-                    // introducing artificial delay, if requested
-                    if (writable && this.txDelay > 0)
-                        await tp.setTimeout(this.txDelay, undefined, { signal: ops?.abortSignal });
-                    return result;
-                }
-            }
-            finally {
-                release();
-            }
-            // we only get here after TxCommitConflict error,
-            // all other errors terminate this loop instantly
-            await tp.setTimeout(retryState.nextDelay, undefined, { signal: ops?.abortSignal });
-            retryState = nextRetryStateOrError(retryState);
-        }
-    }
-    async withTx(name, writable, body, ops = {}) {
-        this.checkInitialized();
-        return await this._withTx(name, writable, this.clientRoot, body, { ...ops, ...defaultTxOps });
-    }
-    async withWriteTx(name, body, ops = {}) {
-        return await this.withTx(name, true, body, { ...ops, ...defaultTxOps });
-    }
-    async withReadTx(name, body, ops = {}) {
-        return await this.withTx(name, false, body, { ...ops, ...defaultTxOps });
-    }
-    getDriver(definition) {
-        const attached = this.drivers.get(definition.name);
-        if (attached !== undefined)
-            return attached;
-        const driver = definition.init(this, this.ll, this.httpDispatcher);
-        this.drivers.set(definition.name, driver);
-        return driver;
-    }
-    /** Closes underlying transport */
-    async close() {
-        await this.ll.close();
-    }
-    static async init(configOrAddress, auth, ops = {}) {
-        const pl = new PlClient(configOrAddress, auth, ops);
-        await pl.init();
-        return pl;
-    }
-}
+var PlClient = class PlClient {
+	drivers = /* @__PURE__ */ new Map();
+	/** Artificial delay introduced after write transactions completion, to
+	* somewhat throttle the load on pl. Delay introduced after sync, if requested. */
+	txDelay;
+	/** Last resort measure to solve complicated race conditions in pl. */
+	forceSync;
+	/** Last resort measure to solve complicated race conditions in pl. */
+	defaultRetryOptions;
+	buildLLPlClient;
+	_ll;
+	get ll() {
+		if (this._ll === void 0) throw new Error("LLPlClient not initialized");
+		return this._ll;
+	}
+	/** Stores client root (this abstraction is intended for future implementation of the security model) */
+	_clientRoot = NullResourceId;
+	_serverInfo = void 0;
+	_txCommittedStat = initialTxStat();
+	_txConflictStat = initialTxStat();
+	_txErrorStat = initialTxStat();
+	/** This function determines whether resource data can be cached */
+	finalPredicate;
+	/** Resource data cache, to minimize redundant data rereading from remote db */
+	resourceDataCache;
+	constructor(configOrAddress, auth, ops = {}) {
+		const conf = typeof configOrAddress === "string" ? plAddressToConfig(configOrAddress) : configOrAddress;
+		this.buildLLPlClient = async (shouldUseGzip, wireProtocol) => {
+			if (wireProtocol) conf.wireProtocol = wireProtocol;
+			return await LLPlClient.build(conf, {
+				auth,
+				...ops,
+				shouldUseGzip
+			});
+		};
+		this.txDelay = conf.txDelay;
+		this.forceSync = conf.forceSync;
+		this.finalPredicate = ops.finalPredicate ?? DefaultFinalResourceDataPredicate;
+		this.resourceDataCache = new LRUCache({
+			maxSize: conf.maxCacheBytes,
+			sizeCalculation: (v) => (v.basicData.data?.length ?? 0) + 64
+		});
+		switch (conf.retryBackoffAlgorithm) {
+			case "exponential":
+				this.defaultRetryOptions = {
+					type: "exponentialBackoff",
+					initialDelay: conf.retryInitialDelay,
+					maxAttempts: conf.retryMaxAttempts,
+					backoffMultiplier: conf.retryExponentialBackoffMultiplier,
+					jitter: conf.retryJitter
+				};
+				break;
+			case "linear":
+				this.defaultRetryOptions = {
+					type: "linearBackoff",
+					initialDelay: conf.retryInitialDelay,
+					maxAttempts: conf.retryMaxAttempts,
+					backoffStep: conf.retryLinearBackoffStep,
+					jitter: conf.retryJitter
+				};
+				break;
+			default: assertNever(conf.retryBackoffAlgorithm);
+		}
+	}
+	get txCommittedStat() {
+		return { ...this._txCommittedStat };
+	}
+	get txConflictStat() {
+		return { ...this._txConflictStat };
+	}
+	get txErrorStat() {
+		return { ...this._txErrorStat };
+	}
+	get txTotalStat() {
+		return addStat(addStat(this._txCommittedStat, this._txConflictStat), this._txErrorStat);
+	}
+	get allTxStat() {
+		return {
+			committed: this.txCommittedStat,
+			conflict: this.txConflictStat,
+			error: this.txErrorStat
+		};
+	}
+	async ping() {
+		return await this.ll.ping();
+	}
+	async license() {
+		return await this.ll.license();
+	}
+	get conf() {
+		return this.ll.conf;
+	}
+	get httpDispatcher() {
+		return this.ll.httpDispatcher;
+	}
+	get connectionOpts() {
+		return this.ll.wireConnection;
+	}
+	get initialized() {
+		return !isNullResourceId(this._clientRoot);
+	}
+	checkInitialized() {
+		if (!this.initialized) throw new Error("Client not initialized");
+	}
+	get clientRoot() {
+		this.checkInitialized();
+		return ensureResourceIdNotNull(this._clientRoot);
+	}
+	get serverInfo() {
+		this.checkInitialized();
+		return this._serverInfo;
+	}
+	/** Currently implements custom logic to emulate future behaviour with single root. */
+	async init() {
+		if (this.initialized) throw new Error("Already initialized");
+		this._ll = await this.buildLLPlClient(false);
+		const wireProtocol = this._ll.wireProtocol;
+		const user = this._ll.authUser;
+		const mainRootName = user === null ? AnonymousClientRoot : createHash("sha256").update(user).digest("hex");
+		this._serverInfo = await this.ping();
+		if (this._serverInfo.compression === MaintenanceAPI_Ping_Response_Compression.GZIP) {
+			await this._ll.close();
+			this._ll = await this.buildLLPlClient(true, wireProtocol);
+		}
+		this._clientRoot = await this._withTx("initialization", true, NullResourceId, async (tx) => {
+			let mainRoot;
+			if (await tx.checkResourceNameExists(mainRootName)) mainRoot = await tx.getResourceByName(mainRootName);
+			else {
+				mainRoot = tx.createRoot(ClientRoot);
+				tx.setResourceName(mainRootName, mainRoot);
+			}
+			if (this.conf.alternativeRoot === void 0) {
+				await tx.commit();
+				return await toGlobalResourceId(mainRoot);
+			} else {
+				const aFId = {
+					resourceId: mainRoot,
+					fieldName: alternativeRootFieldName(this.conf.alternativeRoot)
+				};
+				const altRoot = tx.createEphemeral(ClientRoot);
+				tx.lock(altRoot);
+				tx.createField(aFId, "Dynamic");
+				tx.setField(aFId, altRoot);
+				await tx.commit();
+				return await altRoot.globalId;
+			}
+		});
+	}
+	/** Returns true if field existed */
+	async deleteAlternativeRoot(alternativeRootName) {
+		this.checkInitialized();
+		if (this.ll.conf.alternativeRoot !== void 0) throw new Error("Initialized with alternative root.");
+		return await this.withWriteTx("delete-alternative-root", async (tx) => {
+			const fId = {
+				resourceId: tx.clientRoot,
+				fieldName: alternativeRootFieldName(alternativeRootName)
+			};
+			const exists = tx.fieldExists(fId);
+			tx.removeField(fId);
+			await tx.commit();
+			return await exists;
+		});
+	}
+	async _withTx(name, writable, clientRoot, body, ops) {
+		let retryState = createRetryState(ops?.retryOptions ?? this.defaultRetryOptions);
+		while (true) {
+			const release = ops?.lockId ? await advisoryLock(ops.lockId) : () => {};
+			try {
+				const tx = new PlTransaction(this.ll.createTx(writable, ops), name, writable, clientRoot, this.finalPredicate, this.resourceDataCache);
+				let ok = false;
+				let result = void 0;
+				let txId;
+				try {
+					result = await body(tx);
+					this._txCommittedStat = addStat(this._txCommittedStat, tx.stat);
+					ok = true;
+				} catch (e) {
+					if (e instanceof TxCommitConflict) this._txConflictStat = addStat(this._txConflictStat, tx.stat);
+					else {
+						this._txErrorStat = addStat(this._txErrorStat, tx.stat);
+						throw e;
+					}
+				} finally {
+					await tx.complete();
+					await tx.await();
+					txId = await tx.getGlobalTxId();
+				}
+				if (ok) {
+					if (ops?.sync === void 0 ? this.forceSync : ops?.sync) await this.ll.txSync(txId);
+					if (writable && this.txDelay > 0) await tp.setTimeout(this.txDelay, void 0, { signal: ops?.abortSignal });
+					return result;
+				}
+			} finally {
+				release();
+			}
+			await tp.setTimeout(retryState.nextDelay, void 0, { signal: ops?.abortSignal });
+			retryState = nextRetryStateOrError(retryState);
+		}
+	}
+	async withTx(name, writable, body, ops = {}) {
+		this.checkInitialized();
+		return await this._withTx(name, writable, this.clientRoot, body, {
+			...ops,
+			...defaultTxOps
+		});
+	}
+	async withWriteTx(name, body, ops = {}) {
+		return await this.withTx(name, true, body, {
+			...ops,
+			...defaultTxOps
+		});
+	}
+	async withReadTx(name, body, ops = {}) {
+		return await this.withTx(name, false, body, {
+			...ops,
+			...defaultTxOps
+		});
+	}
+	getDriver(definition) {
+		const attached = this.drivers.get(definition.name);
+		if (attached !== void 0) return attached;
+		const driver = definition.init(this, this.ll, this.httpDispatcher);
+		this.drivers.set(definition.name, driver);
+		return driver;
+	}
+	/** Closes underlying transport */
+	async close() {
+		await this.ll.close();
+	}
+	static async init(configOrAddress, auth, ops = {}) {
+		const pl = new PlClient(configOrAddress, auth, ops);
+		await pl.init();
+		return pl;
+	}
+};
 
+//#endregion
 export { PlClient };
-//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map