@milaboratories/pl-client 2.16.1 → 2.16.2

package/dist/core/transaction.js

@@ -1,4 +1,5 @@
-import { isLocalResourceId, isNullResourceId, ensureResourceIdNotNull, extractBasicResourceData, createLocalResourceId, MaxTxId } from './types.js';
+import { __esDecorate, __runInitializers } from '../__external/.pnpm/@rollup_plugin-typescript@12.1.4_rollup@4.52.4_tslib@2.7.0_typescript@5.6.3/__external/tslib/tslib.es6.js';
+import { ensureResourceIdNotNull, isLocalResourceId, extractBasicResourceData, createLocalResourceId, MaxTxId, isNullResourceId } from './types.js';
 import { TxAPI_Open_Request_WritableTx } from '../proto/github.com/milaboratory/pl/plapi/plapiproto/api.js';
 import { toBytes } from '../util/util.js';
 import { protoToResource, fieldTypeToProto, protoToField } from './type_conversion.js';
@@ -7,6 +8,7 @@ import { isNotFoundError } from './errors.js';
 import { initialTxStatWithoutTime } from './stat.js';
 import { ErrorResourceType } from './error_resource.js';
 import { JsonObject, JsonGzObject } from '../helpers/pl.js';
+import { PromiseTracker } from './PromiseTracker.js';
 
 function isField(ref) {
     return ref.hasOwnProperty('resourceId') && ref.hasOwnProperty('fieldName');
@@ -64,6 +66,15 @@ async function notFoundToUndefined(cb) {
         throw e;
     }
 }
+/**
+ * Decorator that wraps the method's returned promise with this.track()
+ * This ensures that the promise will be awaited before the transaction is completed.
+ */
+function tracked(value, _context) {
+    return function (...args) {
+        return this.track(value.apply(this, args));
+    };
+}
 /**
  * Each platform transaction has 3 stages:
  *   - initialization (txOpen message -> txInfo response)
@@ -72,542 +83,593 @@ async function notFoundToUndefined(cb) {
  *
  * This class encapsulates finalization stage and provides ready-to-communication transaction object.
  * */
-class PlTransaction {
-    ll;
-    name;
-    writable;
-    _clientRoot;
-    finalPredicate;
-    sharedResourceDataCache;
-    enableFormattedErrors;
-    globalTxId;
-    localTxId = PlTransaction.nextLocalTxId();
-    /** Used in caching */
-    txOpenTimestamp = Date.now();
-    localResourceIdCounter = 0;
-    /** Store logical tx open / closed state to prevent invalid sequence of requests.
-     * True means output stream was completed.
-     * Contract: there must be no async operations between setting this field to true and sending complete signal to stream. */
-    _completed = false;
-    /** Void operation futures are placed into this pool, and corresponding method return immediately.
-     * This is done to save number of round-trips. Next operation producing result will also await those
-     * pending ops, to throw any pending errors. */
-    pendingVoidOps = [];
-    globalTxIdWasAwaited = false;
-    _startTime = Date.now();
-    _stat = initialTxStatWithoutTime();
-    get stat() {
-        return {
-            ...this._stat,
-            timeMs: Date.now() - this._startTime,
-        };
-    }
-    constructor(ll, name, writable, _clientRoot, finalPredicate, sharedResourceDataCache, enableFormattedErrors = false) {
-        this.ll = ll;
-        this.name = name;
-        this.writable = writable;
-        this._clientRoot = _clientRoot;
-        this.finalPredicate = finalPredicate;
-        this.sharedResourceDataCache = sharedResourceDataCache;
-        this.enableFormattedErrors = enableFormattedErrors;
-        // initiating transaction
-        this.globalTxId = this.sendSingleAndParse({
-            oneofKind: 'txOpen',
-            txOpen: {
-                name,
-                enableFormattedErrors,
-                writable: writable
-                    ? TxAPI_Open_Request_WritableTx.WRITABLE
-                    : TxAPI_Open_Request_WritableTx.NOT_WRITABLE,
-            },
-        }, (r) => notEmpty(r.txOpen.tx?.id));
-        // To avoid floating promise
-        this.globalTxId.catch((err) => {
-            if (!this.globalTxIdWasAwaited) {
-                console.warn(err);
+let PlTransaction = (() => {
+    let _instanceExtraInitializers = [];
+    let _getResourceData_decorators;
+    let _getResourceDataIfExists_decorators;
+    let _getFieldIfExists_decorators;
+    let _listKeyValues_decorators;
+    let _listKeyValuesString_decorators;
+    let _listKeyValuesIfResourceExists_decorators;
+    let _listKeyValuesStringIfResourceExists_decorators;
+    let _getKValue_decorators;
+    let _getKValueString_decorators;
+    let _getKValueJson_decorators;
+    let _getKValueIfExists_decorators;
+    let _getKValueStringIfExists_decorators;
+    let _getKValueJsonIfExists_decorators;
+    return class PlTransaction {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getResourceData_decorators = [tracked];
+            _getResourceDataIfExists_decorators = [tracked];
+            _getFieldIfExists_decorators = [tracked];
+            _listKeyValues_decorators = [tracked];
+            _listKeyValuesString_decorators = [tracked];
+            _listKeyValuesIfResourceExists_decorators = [tracked];
+            _listKeyValuesStringIfResourceExists_decorators = [tracked];
+            _getKValue_decorators = [tracked];
+            _getKValueString_decorators = [tracked];
+            _getKValueJson_decorators = [tracked];
+            _getKValueIfExists_decorators = [tracked];
+            _getKValueStringIfExists_decorators = [tracked];
+            _getKValueJsonIfExists_decorators = [tracked];
+            __esDecorate(this, null, _getResourceData_decorators, { kind: "method", name: "getResourceData", static: false, private: false, access: { has: obj => "getResourceData" in obj, get: obj => obj.getResourceData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getResourceDataIfExists_decorators, { kind: "method", name: "getResourceDataIfExists", static: false, private: false, access: { has: obj => "getResourceDataIfExists" in obj, get: obj => obj.getResourceDataIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getFieldIfExists_decorators, { kind: "method", name: "getFieldIfExists", static: false, private: false, access: { has: obj => "getFieldIfExists" in obj, get: obj => obj.getFieldIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listKeyValues_decorators, { kind: "method", name: "listKeyValues", static: false, private: false, access: { has: obj => "listKeyValues" in obj, get: obj => obj.listKeyValues }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listKeyValuesString_decorators, { kind: "method", name: "listKeyValuesString", static: false, private: false, access: { has: obj => "listKeyValuesString" in obj, get: obj => obj.listKeyValuesString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listKeyValuesIfResourceExists_decorators, { kind: "method", name: "listKeyValuesIfResourceExists", static: false, private: false, access: { has: obj => "listKeyValuesIfResourceExists" in obj, get: obj => obj.listKeyValuesIfResourceExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listKeyValuesStringIfResourceExists_decorators, { kind: "method", name: "listKeyValuesStringIfResourceExists", static: false, private: false, access: { has: obj => "listKeyValuesStringIfResourceExists" in obj, get: obj => obj.listKeyValuesStringIfResourceExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValue_decorators, { kind: "method", name: "getKValue", static: false, private: false, access: { has: obj => "getKValue" in obj, get: obj => obj.getKValue }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValueString_decorators, { kind: "method", name: "getKValueString", static: false, private: false, access: { has: obj => "getKValueString" in obj, get: obj => obj.getKValueString }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValueJson_decorators, { kind: "method", name: "getKValueJson", static: false, private: false, access: { has: obj => "getKValueJson" in obj, get: obj => obj.getKValueJson }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValueIfExists_decorators, { kind: "method", name: "getKValueIfExists", static: false, private: false, access: { has: obj => "getKValueIfExists" in obj, get: obj => obj.getKValueIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValueStringIfExists_decorators, { kind: "method", name: "getKValueStringIfExists", static: false, private: false, access: { has: obj => "getKValueStringIfExists" in obj, get: obj => obj.getKValueStringIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getKValueJsonIfExists_decorators, { kind: "method", name: "getKValueJsonIfExists", static: false, private: false, access: { has: obj => "getKValueJsonIfExists" in obj, get: obj => obj.getKValueJsonIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        ll = __runInitializers(this, _instanceExtraInitializers);
+        name;
+        writable;
+        _clientRoot;
+        finalPredicate;
+        sharedResourceDataCache;
+        enableFormattedErrors;
+        globalTxId;
+        localTxId = PlTransaction.nextLocalTxId();
+        /** Used in caching */
+        txOpenTimestamp = Date.now();
+        localResourceIdCounter = 0;
+        /** Store logical tx open / closed state to prevent invalid sequence of requests.
+         * True means output stream was completed.
+         * Contract: there must be no async operations between setting this field to true and sending complete signal to stream. */
+        _completed = false;
+        globalTxIdWasAwaited = false;
+        pending = new PromiseTracker();
+        _startTime = Date.now();
+        _stat = initialTxStatWithoutTime();
+        get stat() {
+            return {
+                ...this._stat,
+                timeMs: Date.now() - this._startTime,
+            };
+        }
+        constructor(ll, name, writable, _clientRoot, finalPredicate, sharedResourceDataCache, enableFormattedErrors = false) {
+            this.ll = ll;
+            this.name = name;
+            this.writable = writable;
+            this._clientRoot = _clientRoot;
+            this.finalPredicate = finalPredicate;
+            this.sharedResourceDataCache = sharedResourceDataCache;
+            this.enableFormattedErrors = enableFormattedErrors;
+            // initiating transaction
+            this.globalTxId = this.sendSingleAndParse({
+                oneofKind: 'txOpen',
+                txOpen: {
+                    name,
+                    enableFormattedErrors,
+                    writable: writable
+                        ? TxAPI_Open_Request_WritableTx.WRITABLE
+                        : TxAPI_Open_Request_WritableTx.NOT_WRITABLE,
+                },
+            }, (r) => notEmpty(r.txOpen.tx?.id));
+            void this.track(this.globalTxId);
+            // To avoid floating promise
+            this.globalTxId.catch((err) => {
+                if (!this.globalTxIdWasAwaited) {
+                    console.warn(err);
+                }
+            });
+            // Adding stats
+            this._stat.txCount++;
+        }
+        /**
+         * Collect all pending promises for the transaction finalization.
+         */
+        track(promiseOrCallback) {
+            return this.pending.track(promiseOrCallback);
+        }
+        async drainAndAwaitPendingOps() {
+            // awaiting these pending operations first, to catch any errors
+            await this.pending.awaitAll();
+        }
+        sendSingleAndParse(r, parser) {
+            return this.pending.track(async () => {
+                const rawResponsePromise = this.ll.send(r, false);
+                void this.pending.track(rawResponsePromise);
+                await this.drainAndAwaitPendingOps();
+                // awaiting our result, and parsing the response
+                return parser(await rawResponsePromise);
+            });
+        }
+        sendMultiAndParse(r, parser) {
+            return this.pending.track(async () => {
+                const rawResponsePromise = this.ll.send(r, true);
+                void this.pending.track(rawResponsePromise);
+                await this.drainAndAwaitPendingOps();
+                // awaiting our result, and parsing the response
+                return parser(await rawResponsePromise);
+            });
+        }
+        async sendVoidSync(r) {
+            await this.ll.send(r, false);
+        }
+        /** Requests sent with this method should never produce recoverable errors */
+        sendVoidAsync(r) {
+            void this.track(this.sendVoidSync(r));
+        }
+        checkTxOpen() {
+            if (this._completed)
+                throw new Error('Transaction already closed');
+        }
+        get completed() {
+            return this._completed;
+        }
+        /** Commit & closes transaction. {@link TxCommitConflict} is thrown on
+         * commit conflicts. */
+        async commit() {
+            this.checkTxOpen();
+            // tx will accept no requests after this one
+            this._completed = true;
+            if (!this.writable) {
+                // no need to explicitly commit or reject read-only tx
+                const completeResult = this.track(this.ll.complete());
+                await this.drainAndAwaitPendingOps();
+                await completeResult;
+                await this.ll.await();
+            }
+            else {
+                const commitResponse = this.track(this.sendSingleAndParse({ oneofKind: 'txCommit', txCommit: {} }, (r) => r.txCommit.success));
+                // send closing frame right after commit to save some time on round-trips
+                const completeResult = this.track(this.ll.complete());
+                // now when we pushed all packets into the stream, we should wait for any
+                // pending void operations from before, to catch any errors
+                await this.drainAndAwaitPendingOps();
+                if (!(await commitResponse))
+                    throw new TxCommitConflict();
+                await completeResult;
+                // await event-loop completion
+                await this.ll.await();
             }
-        });
-        // Adding stats
-        this._stat.txCount++;
-    }
-    async drainAndAwaitPendingOps() {
-        if (this.pendingVoidOps.length === 0)
-            return;
-        // drain pending operations into temp array
-        const pending = this.pendingVoidOps;
-        this.pendingVoidOps = [];
-        // awaiting these pending operations first, to catch any errors
-        await Promise.all(pending);
-    }
-    async sendSingleAndParse(r, parser) {
-        // pushing operation packet to server
-        const rawResponsePromise = this.ll.send(r, false);
-        await this.drainAndAwaitPendingOps();
-        // awaiting our result, and parsing the response
-        return parser(await rawResponsePromise);
-    }
-    async sendMultiAndParse(r, parser) {
-        // pushing operation packet to server
-        const rawResponsePromise = this.ll.send(r, true);
-        await this.drainAndAwaitPendingOps();
-        // awaiting our result, and parsing the response
-        return parser(await rawResponsePromise);
-    }
-    async sendVoidSync(r) {
-        await this.ll.send(r, false);
-    }
-    /** Requests sent with this method should never produce recoverable errors */
-    sendVoidAsync(r) {
-        this.pendingVoidOps.push(this.sendVoidSync(r));
-    }
-    checkTxOpen() {
-        if (this._completed)
-            throw new Error('Transaction already closed');
-    }
-    get completed() {
-        return this._completed;
-    }
-    /** Commit & closes transaction. {@link TxCommitConflict} is thrown on
-     * commit conflicts. */
-    async commit() {
-        this.checkTxOpen();
-        // tx will accept no requests after this one
-        this._completed = true;
-        if (!this.writable) {
-            // no need to explicitly commit or reject read-only tx
-            const completeResult = this.ll.complete();
-            await this.drainAndAwaitPendingOps();
-            await completeResult;
-            await this.ll.await();
         }
-        else {
-            // @TODO, also floating promises
-            const commitResponse = this.sendSingleAndParse({ oneofKind: 'txCommit', txCommit: {} }, (r) => r.txCommit.success);
+        async discard() {
+            this.checkTxOpen();
+            // tx will accept no requests after this one
+            this._completed = true;
+            const discardResponse = this.sendVoidSync({ oneofKind: 'txDiscard', txDiscard: {} });
+            void this.track(discardResponse);
             // send closing frame right after commit to save some time on round-trips
-            const completeResult = this.ll.complete();
+            const completeResult = this.track(this.ll.complete());
             // now when we pushed all packets into the stream, we should wait for any
             // pending void operations from before, to catch any errors
             await this.drainAndAwaitPendingOps();
-            if (!(await commitResponse))
-                throw new TxCommitConflict();
+            await discardResponse;
             await completeResult;
-            // await event-loop completion
             await this.ll.await();
         }
-    }
-    async discard() {
-        this.checkTxOpen();
-        // tx will accept no requests after this one
-        this._completed = true;
-        const discardResponse = this.sendVoidSync({ oneofKind: 'txDiscard', txDiscard: {} });
-        // send closing frame right after commit to save some time on round-trips
-        const completeResult = this.ll.complete();
-        // now when we pushed all packets into the stream, we should wait for any
-        // pending void operations from before, to catch any errors
-        await this.drainAndAwaitPendingOps();
-        await discardResponse;
-        await completeResult;
-        await this.ll.await();
-    }
-    //
-    // Main tx methods
-    //
-    get clientRoot() {
-        return ensureResourceIdNotNull(this._clientRoot);
-    }
-    //
-    // Resources
-    //
-    createSingleton(name, type, errorIfExists = false) {
-        const localId = this.nextLocalResourceId(false);
-        const globalId = this.sendSingleAndParse({
-            oneofKind: 'resourceCreateSingleton',
-            resourceCreateSingleton: {
-                type,
-                id: localId,
-                data: Buffer.from(name),
-                errorIfExists,
-            },
-        }, (r) => r.resourceCreateSingleton.resourceId);
-        return { globalId, localId };
-    }
-    async getSingleton(name, loadFields = true) {
-        return await this.sendSingleAndParse({
-            oneofKind: 'resourceGetSingleton',
-            resourceGetSingleton: {
-                data: Buffer.from(name),
-                loadFields,
-            },
-        }, (r) => protoToResource(notEmpty(r.resourceGetSingleton.resource)));
-    }
-    createResource(root, req, parser) {
-        const localId = this.nextLocalResourceId(root);
-        const globalId = this.sendSingleAndParse(req(localId), (r) => parser(r));
-        return { globalId, localId };
-    }
-    createRoot(type) {
-        this._stat.rootsCreated++;
-        return this.createResource(true, (localId) => ({ oneofKind: 'resourceCreateRoot', resourceCreateRoot: { type, id: localId } }), (r) => r.resourceCreateRoot.resourceId);
-    }
-    createStruct(type, data) {
-        this._stat.structsCreated++;
-        this._stat.structsCreatedDataBytes += data?.length ?? 0;
-        return this.createResource(false, (localId) => ({
-            oneofKind: 'resourceCreateStruct',
-            resourceCreateStruct: {
-                type,
-                id: localId,
-                data: data === undefined ? undefined : typeof data === 'string' ? Buffer.from(data) : data,
-            },
-        }), (r) => r.resourceCreateStruct.resourceId);
-    }
-    createEphemeral(type, data) {
-        this._stat.ephemeralsCreated++;
-        this._stat.ephemeralsCreatedDataBytes += data?.length ?? 0;
-        return this.createResource(false, (localId) => ({
-            oneofKind: 'resourceCreateEphemeral',
-            resourceCreateEphemeral: {
-                type,
-                id: localId,
-                data: data === undefined ? undefined : typeof data === 'string' ? Buffer.from(data) : data,
-            },
-        }), (r) => r.resourceCreateEphemeral.resourceId);
-    }
-    createValue(type, data, errorIfExists = false) {
-        this._stat.valuesCreated++;
-        this._stat.valuesCreatedDataBytes += data?.length ?? 0;
-        return this.createResource(false, (localId) => ({
-            oneofKind: 'resourceCreateValue',
-            resourceCreateValue: {
-                type,
-                id: localId,
-                data: typeof data === 'string' ? Buffer.from(data) : data,
-                errorIfExists,
-            },
-        }), (r) => r.resourceCreateValue.resourceId);
-    }
-    createJsonValue(data) {
-        const jsonData = canonicalJsonBytes(data);
-        return this.createValue(JsonObject, jsonData, false);
-    }
-    createJsonGzValue(data, minSizeToGzip = 16_384) {
-        const { data: jsonData, isGzipped } = canonicalJsonGzBytes(data, minSizeToGzip);
-        return this.createValue(isGzipped ? JsonGzObject : JsonObject, jsonData, false);
-    }
-    createError(message) {
-        return this.createValue(ErrorResourceType, JSON.stringify({ message }));
-    }
-    setResourceName(name, rId) {
-        this.sendVoidAsync({
-            oneofKind: 'resourceNameSet',
-            resourceNameSet: { resourceId: toResourceId(rId), name },
-        });
-    }
-    deleteResourceName(name) {
-        this.sendVoidAsync({ oneofKind: 'resourceNameDelete', resourceNameDelete: { name } });
-    }
-    async getResourceByName(name) {
-        return await this.sendSingleAndParse({ oneofKind: 'resourceNameGet', resourceNameGet: { name } }, (r) => ensureResourceIdNotNull(r.resourceNameGet.resourceId));
-    }
-    async checkResourceNameExists(name) {
-        return await this.sendSingleAndParse({ oneofKind: 'resourceNameExists', resourceNameExists: { name } }, (r) => r.resourceNameExists.exists);
-    }
-    removeResource(rId) {
-        this.sendVoidAsync({ oneofKind: 'resourceRemove', resourceRemove: { id: rId } });
-    }
-    async resourceExists(rId) {
-        return await this.sendSingleAndParse({ oneofKind: 'resourceExists', resourceExists: { resourceId: rId } }, (r) => r.resourceExists.exists);
-    }
-    async getResourceData(rId, loadFields = true, ignoreCache = false) {
-        if (!ignoreCache && !isResourceRef(rId) && !isLocalResourceId(rId)) {
-            // checking if we can return result from cache
-            const fromCache = this.sharedResourceDataCache.get(rId);
-            if (fromCache && fromCache.cacheTxOpenTimestamp < this.txOpenTimestamp) {
-                if (!loadFields) {
-                    this._stat.rGetDataCacheHits++;
-                    this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
-                    return fromCache.basicData;
-                }
-                else if (fromCache.data) {
-                    this._stat.rGetDataCacheHits++;
-                    this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
-                    this._stat.rGetDataCacheFields += fromCache.data.fields.length;
-                    return fromCache.data;
-                }
-            }
+        //
+        // Main tx methods
+        //
+        get clientRoot() {
+            return ensureResourceIdNotNull(this._clientRoot);
+        }
+        //
+        // Resources
+        //
+        createSingleton(name, type, errorIfExists = false) {
+            const localId = this.nextLocalResourceId(false);
+            const globalId = this.sendSingleAndParse({
+                oneofKind: 'resourceCreateSingleton',
+                resourceCreateSingleton: {
+                    type,
+                    id: localId,
+                    data: Buffer.from(name),
+                    errorIfExists,
+                },
+            }, (r) => r.resourceCreateSingleton.resourceId);
+            void this.track(globalId);
+            return { globalId, localId };
+        }
+        getSingleton(name, loadFields = true) {
+            return this.sendSingleAndParse({
+                oneofKind: 'resourceGetSingleton',
+                resourceGetSingleton: {
+                    data: Buffer.from(name),
+                    loadFields,
+                },
+            }, (r) => protoToResource(notEmpty(r.resourceGetSingleton.resource)));
+        }
+        createResource(root, req, parser) {
+            const localId = this.nextLocalResourceId(root);
+            const globalId = this.sendSingleAndParse(req(localId), (r) => parser(r));
+            void this.track(globalId);
+            return { globalId, localId };
+        }
+        createRoot(type) {
+            this._stat.rootsCreated++;
+            return this.createResource(true, (localId) => ({ oneofKind: 'resourceCreateRoot', resourceCreateRoot: { type, id: localId } }), (r) => r.resourceCreateRoot.resourceId);
+        }
+        createStruct(type, data) {
+            this._stat.structsCreated++;
+            this._stat.structsCreatedDataBytes += data?.length ?? 0;
+            return this.createResource(false, (localId) => ({
+                oneofKind: 'resourceCreateStruct',
+                resourceCreateStruct: {
+                    type,
+                    id: localId,
+                    data: data === undefined ? undefined : typeof data === 'string' ? Buffer.from(data) : data,
+                },
+            }), (r) => r.resourceCreateStruct.resourceId);
+        }
+        createEphemeral(type, data) {
+            this._stat.ephemeralsCreated++;
+            this._stat.ephemeralsCreatedDataBytes += data?.length ?? 0;
+            return this.createResource(false, (localId) => ({
+                oneofKind: 'resourceCreateEphemeral',
+                resourceCreateEphemeral: {
+                    type,
+                    id: localId,
+                    data: data === undefined ? undefined : typeof data === 'string' ? Buffer.from(data) : data,
+                },
+            }), (r) => r.resourceCreateEphemeral.resourceId);
+        }
+        createValue(type, data, errorIfExists = false) {
+            this._stat.valuesCreated++;
+            this._stat.valuesCreatedDataBytes += data?.length ?? 0;
+            return this.createResource(false, (localId) => ({
+                oneofKind: 'resourceCreateValue',
+                resourceCreateValue: {
+                    type,
+                    id: localId,
+                    data: typeof data === 'string' ? Buffer.from(data) : data,
+                    errorIfExists,
+                },
+            }), (r) => r.resourceCreateValue.resourceId);
+        }
+        createJsonValue(data) {
+            const jsonData = canonicalJsonBytes(data);
+            return this.createValue(JsonObject, jsonData, false);
+        }
+        createJsonGzValue(data, minSizeToGzip = 16_384) {
+            const { data: jsonData, isGzipped } = canonicalJsonGzBytes(data, minSizeToGzip);
+            return this.createValue(isGzipped ? JsonGzObject : JsonObject, jsonData, false);
+        }
+        createError(message) {
+            return this.createValue(ErrorResourceType, JSON.stringify({ message }));
+        }
+        setResourceName(name, rId) {
+            this.sendVoidAsync({
+                oneofKind: 'resourceNameSet',
+                resourceNameSet: { resourceId: toResourceId(rId), name },
+            });
+        }
+        deleteResourceName(name) {
+            this.sendVoidAsync({ oneofKind: 'resourceNameDelete', resourceNameDelete: { name } });
+        }
+        getResourceByName(name) {
+            return this.sendSingleAndParse({ oneofKind: 'resourceNameGet', resourceNameGet: { name } }, (r) => ensureResourceIdNotNull(r.resourceNameGet.resourceId));
+        }
+        checkResourceNameExists(name) {
+            return this.sendSingleAndParse({ oneofKind: 'resourceNameExists', resourceNameExists: { name } }, (r) => r.resourceNameExists.exists);
+        }
+        removeResource(rId) {
+            this.sendVoidAsync({ oneofKind: 'resourceRemove', resourceRemove: { id: rId } });
         }
-        const result = await this.sendSingleAndParse({
-            oneofKind: 'resourceGet',
-            resourceGet: { resourceId: toResourceId(rId), loadFields: loadFields },
-        }, (r) => protoToResource(notEmpty(r.resourceGet.resource)));
-        this._stat.rGetDataNetRequests++;
-        this._stat.rGetDataNetBytes += result.data?.length ?? 0;
-        this._stat.rGetDataNetFields += result.fields.length;
-        // we will cache only final resource data states
-        // caching result even if we were ignore the cache
-        if (!isResourceRef(rId) && !isLocalResourceId(rId) && this.finalPredicate(result)) {
-            deepFreeze(result);
-            const fromCache = this.sharedResourceDataCache.get(rId);
-            if (fromCache) {
-                if (loadFields && !fromCache.data) {
-                    fromCache.data = result;
-                    // updating timestamp becuse we updated the record
-                    fromCache.cacheTxOpenTimestamp = this.txOpenTimestamp;
+        resourceExists(rId) {
+            return this.sendSingleAndParse({ oneofKind: 'resourceExists', resourceExists: { resourceId: rId } }, (r) => r.resourceExists.exists);
+        }
+        async getResourceData(rId, loadFields = true, ignoreCache = false) {
+            if (!ignoreCache && !isResourceRef(rId) && !isLocalResourceId(rId)) {
+                // checking if we can return result from cache
+                const fromCache = this.sharedResourceDataCache.get(rId);
+                if (fromCache && fromCache.cacheTxOpenTimestamp < this.txOpenTimestamp) {
+                    if (!loadFields) {
+                        this._stat.rGetDataCacheHits++;
+                        this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+                        return fromCache.basicData;
+                    }
+                    else if (fromCache.data) {
+                        this._stat.rGetDataCacheHits++;
+                        this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+                        this._stat.rGetDataCacheFields += fromCache.data.fields.length;
+                        return fromCache.data;
+                    }
                 }
             }
-            else {
-                const basicData = extractBasicResourceData(result);
-                deepFreeze(basicData);
-                if (loadFields)
-                    this.sharedResourceDataCache.set(rId, {
-                        basicData,
-                        data: result,
-                        cacheTxOpenTimestamp: this.txOpenTimestamp,
-                    });
-                else
-                    this.sharedResourceDataCache.set(rId, {
-                        basicData,
-                        data: undefined,
-                        cacheTxOpenTimestamp: this.txOpenTimestamp,
-                    });
+            const result = await this.sendSingleAndParse({
+                oneofKind: 'resourceGet',
+                resourceGet: { resourceId: toResourceId(rId), loadFields: loadFields },
+            }, (r) => protoToResource(notEmpty(r.resourceGet.resource)));
+            this._stat.rGetDataNetRequests++;
+            this._stat.rGetDataNetBytes += result.data?.length ?? 0;
+            this._stat.rGetDataNetFields += result.fields.length;
+            // we will cache only final resource data states
+            // caching result even if we were ignore the cache
+            if (!isResourceRef(rId) && !isLocalResourceId(rId) && this.finalPredicate(result)) {
+                deepFreeze(result);
+                const fromCache = this.sharedResourceDataCache.get(rId);
+                if (fromCache) {
+                    if (loadFields && !fromCache.data) {
+                        fromCache.data = result;
+                        // updating timestamp because we updated the record
+                        fromCache.cacheTxOpenTimestamp = this.txOpenTimestamp;
+                    }
+                }
+                else {
+                    const basicData = extractBasicResourceData(result);
+                    deepFreeze(basicData);
+                    if (loadFields)
+                        this.sharedResourceDataCache.set(rId, {
+                            basicData,
+                            data: result,
+                            cacheTxOpenTimestamp: this.txOpenTimestamp,
+                        });
+                    else
+                        this.sharedResourceDataCache.set(rId, {
+                            basicData,
+                            data: undefined,
+                            cacheTxOpenTimestamp: this.txOpenTimestamp,
+                        });
+                }
             }
+            return result;
         }
-        return result;
-    }
-    async getResourceDataIfExists(rId, loadFields = true) {
-        // calling this mehtod will ignore cache, because user intention is to detect resource absence
-        // which cache will prevent
-        const result = await notFoundToUndefined(async () => await this.getResourceData(rId, loadFields, true));
-        // cleaning cache record if resorce was removed from the db
-        if (result === undefined && !isResourceRef(rId) && !isLocalResourceId(rId))
-            this.sharedResourceDataCache.delete(rId);
-        return result;
-    }
-    /**
-     * Inform platform that resource will not get any new input fields.
-     * This is required, when client creates resource without schema and wants
-     * controller to start calculations.
-     * Most controllers will not start calculations even when all inputs
-     * have their values, if inputs list is not locked.
-     */
-    lockInputs(rId) {
-        this._stat.inputsLocked++;
-        this.sendVoidAsync({
-            oneofKind: 'resourceLockInputs',
-            resourceLockInputs: { resourceId: toResourceId(rId) },
-        });
-    }
-    /**
-     * Inform platform that resource will not get any new output fields.
-     * This is required for resource to pass deduplication.
-     */
-    lockOutputs(rId) {
-        this._stat.outputsLocked++;
-        this.sendVoidAsync({
-            oneofKind: 'resourceLockOutputs',
-            resourceLockOutputs: { resourceId: toResourceId(rId) },
-        });
-    }
-    lock(rID) {
-        this.lockInputs(rID);
-        this.lockOutputs(rID);
-    }
-    setResourceError(rId, ref) {
-        this.sendVoidAsync({
-            oneofKind: 'resourceSetError',
-            resourceSetError: { resourceId: toResourceId(rId), errorResourceId: toResourceId(ref) },
-        });
-    }
-    //
-    // Fields
-    //
-    createField(fId, fieldType, value) {
-        this._stat.fieldsCreated++;
-        this.sendVoidAsync({
-            oneofKind: 'fieldCreate',
-            fieldCreate: { type: fieldTypeToProto(fieldType), id: toFieldId(fId) },
-        });
-        if (value !== undefined)
-            this.setField(fId, value);
-    }
-    async fieldExists(fId) {
-        return await this.sendSingleAndParse({
-            oneofKind: 'fieldExists',
-            fieldExists: { field: toFieldId(fId) },
-        }, (r) => r.fieldExists.exists);
-    }
-    setField(fId, ref) {
-        this._stat.fieldsSet++;
-        if (isResource(ref))
+        async getResourceDataIfExists(rId, loadFields = true) {
+            // calling this method will ignore cache, because user intention is to detect resource absence
+            // which cache will prevent
+            const result = await notFoundToUndefined(async () => await this.getResourceData(rId, loadFields, true));
+            // cleaning cache record if resource was removed from the db
+            if (result === undefined && !isResourceRef(rId) && !isLocalResourceId(rId))
+                this.sharedResourceDataCache.delete(rId);
+            return result;
+        }
+        /**
+         * Inform platform that resource will not get any new input fields.
+         * This is required, when client creates resource without schema and wants
+         * controller to start calculations.
+         * Most controllers will not start calculations even when all inputs
+         * have their values, if inputs list is not locked.
+         */
+        lockInputs(rId) {
+            this._stat.inputsLocked++;
+            this.sendVoidAsync({
+                oneofKind: 'resourceLockInputs',
+                resourceLockInputs: { resourceId: toResourceId(rId) },
+            });
+        }
+        /**
+         * Inform platform that resource will not get any new output fields.
+         * This is required for resource to pass deduplication.
+         */
+        lockOutputs(rId) {
+            this._stat.outputsLocked++;
             this.sendVoidAsync({
-                oneofKind: 'fieldSet',
-                fieldSet: {
-                    field: toFieldId(fId),
-                    value: {
-                        resourceId: toResourceId(ref),
-                        fieldName: '', // default value, read as undefined
+                oneofKind: 'resourceLockOutputs',
+                resourceLockOutputs: { resourceId: toResourceId(rId) },
+            });
+        }
+        lock(rID) {
+            this.lockInputs(rID);
+            this.lockOutputs(rID);
+        }
+        setResourceError(rId, ref) {
+            this.sendVoidAsync({
+                oneofKind: 'resourceSetError',
+                resourceSetError: { resourceId: toResourceId(rId), errorResourceId: toResourceId(ref) },
+            });
+        }
+        //
+        // Fields
+        //
+        createField(fId, fieldType, value) {
+            this._stat.fieldsCreated++;
+            this.sendVoidAsync({
+                oneofKind: 'fieldCreate',
+                fieldCreate: { type: fieldTypeToProto(fieldType), id: toFieldId(fId) },
+            });
+            if (value !== undefined)
+                this.setField(fId, value);
+        }
+        fieldExists(fId) {
+            return this.sendSingleAndParse({
+                oneofKind: 'fieldExists',
+                fieldExists: { field: toFieldId(fId) },
+            }, (r) => r.fieldExists.exists);
+        }
+        setField(fId, ref) {
+            this._stat.fieldsSet++;
+            if (isResource(ref))
+                this.sendVoidAsync({
+                    oneofKind: 'fieldSet',
+                    fieldSet: {
+                        field: toFieldId(fId),
+                        value: {
+                            resourceId: toResourceId(ref),
+                            fieldName: '', // default value, read as undefined
+                        },
                     },
+                });
+            else
+                this.sendVoidAsync({
+                    oneofKind: 'fieldSet',
+                    fieldSet: {
+                        field: toFieldId(fId),
+                        value: toFieldId(ref),
+                    },
+                });
+        }
+        setFieldError(fId, ref) {
+            this._stat.fieldsSet++;
+            this.sendVoidAsync({
+                oneofKind: 'fieldSetError',
+                fieldSetError: { field: toFieldId(fId), errResourceId: toResourceId(ref) },
+            });
+        }
+        getField(fId) {
+            this._stat.fieldsGet++;
+            return this.sendSingleAndParse({ oneofKind: 'fieldGet', fieldGet: { field: toFieldId(fId) } }, (r) => protoToField(notEmpty(r.fieldGet.field)));
+        }
+        async getFieldIfExists(fId) {
+            return notFoundToUndefined(async () => await this.getField(fId));
+        }
+        resetField(fId) {
+            this.sendVoidAsync({ oneofKind: 'fieldReset', fieldReset: { field: toFieldId(fId) } });
+        }
+        removeField(fId) {
+            this.sendVoidAsync({ oneofKind: 'fieldRemove', fieldRemove: { field: toFieldId(fId) } });
+        }
+        //
+        // KV
+        //
+        async listKeyValues(rId) {
+            const result = await this.sendMultiAndParse({
+                oneofKind: 'resourceKeyValueList',
+                resourceKeyValueList: { resourceId: toResourceId(rId), startFrom: '', limit: 0 },
+            }, (r) => r.map((e) => e.resourceKeyValueList.record));
+            this._stat.kvListRequests++;
+            this._stat.kvListEntries += result.length;
+            for (const kv of result)
+                this._stat.kvListBytes += kv.key.length + kv.value.length;
+            return result;
+        }
+        async listKeyValuesString(rId) {
+            return (await this.listKeyValues(rId)).map(({ key, value }) => ({
+                key,
+                value: Buffer.from(value).toString(),
+            }));
+        }
+        async listKeyValuesIfResourceExists(rId) {
+            return notFoundToUndefined(async () => await this.listKeyValues(rId));
+        }
+        async listKeyValuesStringIfResourceExists(rId) {
+            return notFoundToUndefined(async () => await this.listKeyValuesString(rId));
+        }
+        setKValue(rId, key, value) {
+            this._stat.kvSetRequests++;
+            this._stat.kvSetBytes++;
+            this.sendVoidAsync({
+                oneofKind: 'resourceKeyValueSet',
+                resourceKeyValueSet: {
+                    resourceId: toResourceId(rId),
+                    key,
+                    value: toBytes(value),
                 },
             });
-        else
+        }
+        deleteKValue(rId, key) {
             this.sendVoidAsync({
-                oneofKind: 'fieldSet',
-                fieldSet: {
-                    field: toFieldId(fId),
-                    value: toFieldId(ref),
+                oneofKind: 'resourceKeyValueDelete',
+                resourceKeyValueDelete: {
+                    resourceId: toResourceId(rId),
+                    key,
                 },
             });
-    }
-    setFieldError(fId, ref) {
-        this._stat.fieldsSet++;
-        this.sendVoidAsync({
-            oneofKind: 'fieldSetError',
-            fieldSetError: { field: toFieldId(fId), errResourceId: toResourceId(ref) },
-        });
-    }
-    async getField(fId) {
-        this._stat.fieldsGet++;
-        return await this.sendSingleAndParse({ oneofKind: 'fieldGet', fieldGet: { field: toFieldId(fId) } }, (r) => protoToField(notEmpty(r.fieldGet.field)));
-    }
-    async getFieldIfExists(fId) {
-        return notFoundToUndefined(async () => await this.getField(fId));
-    }
-    resetField(fId) {
-        this.sendVoidAsync({ oneofKind: 'fieldReset', fieldReset: { field: toFieldId(fId) } });
-    }
-    removeField(fId) {
-        this.sendVoidAsync({ oneofKind: 'fieldRemove', fieldRemove: { field: toFieldId(fId) } });
-    }
-    //
-    // KV
-    //
-    async listKeyValues(rId) {
-        const result = await this.sendMultiAndParse({
-            oneofKind: 'resourceKeyValueList',
-            resourceKeyValueList: { resourceId: toResourceId(rId), startFrom: '', limit: 0 },
-        }, (r) => r.map((e) => e.resourceKeyValueList.record));
-        this._stat.kvListRequests++;
-        this._stat.kvListEntries += result.length;
-        for (const kv of result)
-            this._stat.kvListBytes += kv.key.length + kv.value.length;
-        return result;
-    }
-    async listKeyValuesString(rId) {
-        return (await this.listKeyValues(rId)).map(({ key, value }) => ({
-            key,
-            value: Buffer.from(value).toString(),
-        }));
-    }
-    async listKeyValuesIfResourceExists(rId) {
-        return notFoundToUndefined(async () => await this.listKeyValues(rId));
-    }
-    async listKeyValuesStringIfResourceExists(rId) {
-        return notFoundToUndefined(async () => await this.listKeyValuesString(rId));
-    }
-    setKValue(rId, key, value) {
-        this._stat.kvSetRequests++;
-        this._stat.kvSetBytes++;
-        this.sendVoidAsync({
-            oneofKind: 'resourceKeyValueSet',
-            resourceKeyValueSet: {
-                resourceId: toResourceId(rId),
-                key,
-                value: toBytes(value),
-            },
-        });
-    }
-    deleteKValue(rId, key) {
-        this.sendVoidAsync({
-            oneofKind: 'resourceKeyValueDelete',
-            resourceKeyValueDelete: {
-                resourceId: toResourceId(rId),
-                key,
-            },
-        });
-    }
-    async getKValue(rId, key) {
-        const result = await this.sendSingleAndParse({
-            oneofKind: 'resourceKeyValueGet',
-            resourceKeyValueGet: { resourceId: toResourceId(rId), key },
-        }, (r) => r.resourceKeyValueGet.value);
-        this._stat.kvGetRequests++;
-        this._stat.kvGetBytes += result.length;
-        return result;
-    }
-    async getKValueString(rId, key) {
-        return Buffer.from(await this.getKValue(rId, key)).toString();
-    }
-    async getKValueJson(rId, key) {
-        return JSON.parse(await this.getKValueString(rId, key));
-    }
-    async getKValueIfExists(rId, key) {
-        const result = await this.sendSingleAndParse({
-            oneofKind: 'resourceKeyValueGetIfExists',
-            resourceKeyValueGetIfExists: { resourceId: toResourceId(rId), key },
-        }, (r) => r.resourceKeyValueGetIfExists.exists ? r.resourceKeyValueGetIfExists.value : undefined);
-        this._stat.kvGetRequests++;
-        this._stat.kvGetBytes += result?.length ?? 0;
-        return result;
-    }
-    async getKValueStringIfExists(rId, key) {
-        const data = await this.getKValueIfExists(rId, key);
-        return data === undefined ? undefined : Buffer.from(data).toString();
-    }
-    async getKValueJsonIfExists(rId, key) {
-        const str = await this.getKValueString(rId, key);
-        if (str === undefined)
-            return undefined;
-        return JSON.parse(str);
-    }
-    //
-    // Cache
-    //
-    // TODO
-    //
-    // High level ops
-    //
-    /** Resolves existing or create first level resource from */
-    getFutureFieldValue(rId, fieldName, fieldType) {
-        const data = Buffer.from(JSON.stringify({ fieldName, fieldType }));
-        const getFieldResource = this.createEphemeral({ name: 'json/getField', version: '1' }, data);
-        this.setField({ resourceId: getFieldResource, fieldName: 'resource' }, rId);
-        return { resourceId: getFieldResource, fieldName: 'result' };
-    }
-    //
-    // Technical
-    //
-    async getGlobalTxId() {
-        this.globalTxIdWasAwaited = true;
-        return await this.globalTxId;
-    }
-    /** Closes output event stream */
-    async complete() {
-        if (this._completed)
-            return;
-        this._completed = true;
-        const completeResult = this.ll.complete();
-        await this.drainAndAwaitPendingOps();
-        await completeResult;
-    }
-    /** Await incoming message loop termination and throw
-     * any leftover errors if it was unsuccessful */
-    async await() {
-        await this.ll.await();
-    }
-    //
-    // Helpers
-    //
-    nextLocalResourceId(root) {
-        return createLocalResourceId(root, ++this.localResourceIdCounter, this.localTxId);
-    }
-    static localTxIdCounter = 0;
-    static nextLocalTxId() {
-        PlTransaction.localTxIdCounter++;
-        if (PlTransaction.localTxIdCounter === MaxTxId)
-            PlTransaction.localTxIdCounter = 1;
-        return PlTransaction.localTxIdCounter;
-    }
-}
+        }
+        async getKValue(rId, key) {
+            const result = await this.sendSingleAndParse({
+                oneofKind: 'resourceKeyValueGet',
+                resourceKeyValueGet: { resourceId: toResourceId(rId), key },
+            }, (r) => r.resourceKeyValueGet.value);
+            this._stat.kvGetRequests++;
+            this._stat.kvGetBytes += result.length;
+            return result;
+        }
+        async getKValueString(rId, key) {
+            return Buffer.from(await this.getKValue(rId, key)).toString();
+        }
+        async getKValueJson(rId, key) {
+            return JSON.parse(await this.getKValueString(rId, key));
+        }
+        async getKValueIfExists(rId, key) {
+            const result = await this.sendSingleAndParse({
+                oneofKind: 'resourceKeyValueGetIfExists',
+                resourceKeyValueGetIfExists: { resourceId: toResourceId(rId), key },
+            }, (r) => r.resourceKeyValueGetIfExists.exists ? r.resourceKeyValueGetIfExists.value : undefined);
+            this._stat.kvGetRequests++;
+            this._stat.kvGetBytes += result?.length ?? 0;
+            return result;
+        }
+        async getKValueStringIfExists(rId, key) {
+            const data = await this.getKValueIfExists(rId, key);
+            return data === undefined ? undefined : Buffer.from(data).toString();
+        }
+        async getKValueJsonIfExists(rId, key) {
+            const str = await this.getKValueString(rId, key);
+            if (str === undefined)
+                return undefined;
+            return JSON.parse(str);
+        }
+        //
+        // Cache
+        //
+        // TODO
+        //
+        // High level ops
+        //
+        /** Resolves existing or create first level resource from */
+        getFutureFieldValue(rId, fieldName, fieldType) {
+            const data = Buffer.from(JSON.stringify({ fieldName, fieldType }));
+            const getFieldResource = this.createEphemeral({ name: 'json/getField', version: '1' }, data);
+            this.setField({ resourceId: getFieldResource, fieldName: 'resource' }, rId);
+            return { resourceId: getFieldResource, fieldName: 'result' };
+        }
+        //
+        // Technical
+        //
+        async getGlobalTxId() {
+            this.globalTxIdWasAwaited = true;
+            return await this.globalTxId;
+        }
+        /** Closes output event stream */
+        async complete() {
+            if (this._completed)
+                return;
+            this._completed = true;
+            const completeResult = this.track(this.ll.complete());
+            await this.drainAndAwaitPendingOps();
+            await completeResult;
+        }
+        /** Await incoming message loop termination and throw
+         * any leftover errors if it was unsuccessful */
+        async await() {
+            await this.ll.await();
+        }
+        //
+        // Helpers
+        //
+        nextLocalResourceId(root) {
+            return createLocalResourceId(root, ++this.localResourceIdCounter, this.localTxId);
+        }
+        static localTxIdCounter = 0;
+        static nextLocalTxId() {
+            PlTransaction.localTxIdCounter++;
+            if (PlTransaction.localTxIdCounter === MaxTxId)
+                PlTransaction.localTxIdCounter = 1;
+            return PlTransaction.localTxIdCounter;
+        }
+    };
+})();
 
 export { PlTransaction, TxCommitConflict, field, isField, isFieldRef, isResource, isResourceId, isResourceRef, toFieldId, toGlobalFieldId, toGlobalResourceId, toResourceId };
 //# sourceMappingURL=transaction.js.map